discourse/spec/models/topic_embed_spec.rb

# frozen_string_literal: true

require "stringio"

RSpec.describe TopicEmbed do
  it { is_expected.to belong_to :topic }
  it { is_expected.to belong_to :post }
  it { is_expected.to validate_presence_of :embed_url }

  describe ".import" do
    fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }
    let(:title) { "How to turn a fish from good to evil in 30 seconds" }
    let(:url) { "http://eviltrout.com/123" }
    let(:contents) do
      "<p>hello world new post <a href='/hello'>hello</a> <img src='images/wat.jpg'></p>"
    end
    fab!(:embeddable_host)
    fab!(:category)
    fab!(:tag)

    it "returns nil when the URL is malformed" do
      expect(TopicEmbed.import(user, "invalid url", title, contents)).to eq(nil)
      expect(TopicEmbed.count).to eq(0)
    end

    it "Allows figure, figcaption, details HTML tags" do
      html = <<~HTML
        <html>
        <head>
           <title>Some title</title>
        </head>
        <body>
          <div class='content'>
            <p>some content</p>
            <figure>
              <img src="/a.png">
              <figcaption>Some caption</figcaption>
            </figure>
            <details>
              some details
            </details>
          </div>
        </body>
        </html>
      HTML

      parsed = TopicEmbed.parse_html(html, "https://blog.discourse.com/somepost.html")

      # div inception is inserted by the readability gem
      expected = <<~HTML
        <div><div>
          <div>
            <p>some content</p>
            <figure>
              <img src="https://blog.discourse.com/a.png">
              <figcaption>Some caption</figcaption>
            </figure>
            <details>
              some details
            </details>
          </div>
        </div></div>
      HTML
      expect(parsed.body.strip).to eq(expected.strip)
    end

    # ideally, articles get a heavier weightage than td elements
    # so to force that, we do not allow td elements to be scored
    it "does not score td tags" do
      html = <<~HTML
        <html>
        <head>
           <title>Some title</title>
        </head>
        <body>
          <article>
            article content
            <table>
              <tr>
                <td>
                  <p>cats</p>
                  <p>cats</p>
                </td>
              </tr>
            </table>
          </article>
        </body>
        </html>
      HTML

      parsed = TopicEmbed.parse_html(html, "https://blog.discourse.com/somepost.html")

      expected = <<-HTML
        <div><div>
  
    article content
    
      
        
          cats
          cats
        
      
    
  
</div></div>
      HTML
      expect(parsed.body.strip).to eq(expected.strip)
    end

    context "when creating a post" do
      let!(:post) { TopicEmbed.import(user, url, title, contents) }
      let(:topic_embed) { TopicEmbed.find_by(post: post) }

      it "works as expected with a new URL" do
        expect(post).to be_present

        # It uses raw_html rendering
        expect(post.cook_method).to eq(Post.cook_methods[:raw_html])
        expect(post.cooked).to eq(post.raw)

        # It converts relative URLs to absolute
        expect(post.cooked).to have_tag("a", with: { href: "http://eviltrout.com/hello" })
        expect(post.cooked).to have_tag("img", with: { src: "http://eviltrout.com/images/wat.jpg" })

        # It caches the embed content
        expect(post.topic.topic_embed.embed_content_cache).to eq(contents)

        # It converts relative URLs to absolute when expanded
        stub_request(:get, url).to_return(status: 200, body: contents)
        expect(TopicEmbed.expanded_for(post)).to have_tag(
          "img",
          with: {
            src: "http://eviltrout.com/images/wat.jpg",
          },
        )

        expect(post.topic.has_topic_embed?).to eq(true)
        expect(TopicEmbed.where(topic_id: post.topic_id)).to be_present

        expect(post.topic.category).to eq(embeddable_host.category)
        expect(post.topic).not_to be_visible
      end

      it "Supports updating the post content" do
        expect do
          TopicEmbed.import(user, url, "New title received", "<p>muhahaha new contents!</p>")
        end.to change { topic_embed.reload.content_sha1 }
        expect(topic_embed.topic.title).to eq("New title received")

        expect(topic_embed.post.cooked).to match(/new contents/)
      end

      it "Supports updating the post author" do
        new_user = Fabricate(:user)
        TopicEmbed.import(new_user, url, title, contents)

        topic_embed.reload
        expect(topic_embed.post.user).to eq(new_user)
        expect(topic_embed.post.topic.user).to eq(new_user)
      end

      it "Supports updating the embed content cache" do
        expect do TopicEmbed.import(user, url, title, "new contents") end.to change {
          topic_embed.reload.embed_content_cache
        }
        expect(topic_embed.embed_content_cache).to eq("new contents")
      end

      it "Should leave uppercase Feed Entry URL untouched in content" do
        cased_url = "http://eviltrout.com/ABCD"
        post = TopicEmbed.import(user, cased_url, title, "some random content")
        expect(post.cooked).to match(/#{cased_url}/)
      end

      it "Should leave lowercase Feed Entry URL untouched in content" do
        cased_url = "http://eviltrout.com/abcd"
        post = TopicEmbed.import(user, cased_url, title, "some random content")
        expect(post.cooked).to match(/#{cased_url}/)
      end

      shared_examples "topic is unlisted" do
        it "unlists the topic until someone replies" do
          Jobs.run_immediately!
          imported_post =
            TopicEmbed.import(user, "http://eviltrout.com/abcd", title, "some random content")
          expect(imported_post.topic).not_to be_visible
          pc =
            PostCreator.new(
              Fabricate(:user),
              raw: "this is a reply that will make the topic visible",
              topic_id: imported_post.topic_id,
              reply_to_post_number: 1,
            )
          pc.create
          expect(imported_post.topic.reload).to be_visible
        end
      end

      context "when import embed unlisted is true" do
        before { SiteSetting.import_embed_unlisted = true }

        include_examples "topic is unlisted"

        context "when embed unlisted is false" do
          before { SiteSetting.embed_unlisted = false }

          include_examples "topic is unlisted"
        end
      end

      context "when import embed unlisted is false" do
        before { SiteSetting.import_embed_unlisted = false }

        context "when embed unlisted is false" do
          before { SiteSetting.embed_unlisted = false }

          it "lists the topic" do
            Jobs.run_immediately!
            imported_post =
              TopicEmbed.import(user, "http://eviltrout.com/abcd", title, "some random content")
            expect(imported_post.topic).to be_visible
          end
        end

        context "when embed unlisted is true" do
          before { SiteSetting.embed_unlisted = true }

          include_examples "topic is unlisted"
        end
      end

      it "creates the topic in the category passed as a parameter" do
        Jobs.run_immediately!
        imported_post =
          TopicEmbed.import(
            user,
            "http://eviltrout.com/abcd",
            title,
            "some random content",
            category_id: category.id,
          )
        expect(imported_post.topic.category).not_to eq(embeddable_host.category)
        expect(imported_post.topic.category).to eq(category)
      end

      it "does not create duplicate topics with different protocols in the embed_url" do
        Jobs.run_immediately!
        expect {
          TopicEmbed.import(user, "http://eviltrout.com/abcd", title, "some random content")
        }.to change { Topic.all.count }.by(1)

        expect {
          TopicEmbed.import(user, "https://eviltrout.com/abcd", title, "some random content")
        }.to_not change { Topic.all.count }
      end

      it "creates the topic with the tag passed as a parameter" do
        Jobs.run_immediately!
        SiteSetting.tagging_enabled = true
        imported_post =
          TopicEmbed.import(
            user,
            "http://eviltrout.com/abcd",
            title,
            "some random content",
            tags: [tag.name],
          )
        expect(imported_post.topic.tags).to include(tag)
      end

      it "respects overriding the cook_method when asked" do
        Jobs.run_immediately!
        SiteSetting.embed_support_markdown = false
        stub_request(:get, "https://www.youtube.com/watch?v=K56soYl0U1w").to_return(
          status: 200,
          body: "",
          headers: {
          },
        )
        stub_request(:get, "https://www.youtube.com/embed/K56soYl0U1w").to_return(
          status: 200,
          body: "",
          headers: {
          },
        )

        imported_post =
          TopicEmbed.import(
            user,
            "http://eviltrout.com/abcd",
            title,
            "https://www.youtube.com/watch?v=K56soYl0U1w",
            cook_method: Post.cook_methods[:regular],
          )
        expect(imported_post.cooked).to match(/onebox|iframe/)
      end

      describe "topic_embed_import_create_args modifier" do
        after { DiscoursePluginRegistry.clear_modifiers! }

        it "can alter the args used to create the topic" do
          plugin = Plugin::Instance.new
          plugin.register_modifier(:topic_embed_import_create_args) do |args|
            args[:title] = "MODIFIED: #{args[:title]}"

            args
          end

          Jobs.run_immediately!
          imported_post =
            TopicEmbed.import(
              user,
              "http://eviltrout.com/abcd",
              title,
              "some random content",
              category_id: category.id,
            )
          expect(imported_post.topic.title).to eq("MODIFIED: #{title}")
        end

        it "will revert to defaults if the modifier returns nil" do
          plugin = Plugin::Instance.new
          plugin.register_modifier(:topic_embed_import_create_args) { |args| nil }

          Jobs.run_immediately!
          imported_post =
            TopicEmbed.import(
              user,
              "http://eviltrout.com/abcd",
              title,
              "some random content",
              category_id: category.id,
            )
          expect(imported_post.topic.title).to eq(title)
        end
      end
    end

    context "when post creation supports markdown rendering" do
      before { SiteSetting.embed_support_markdown = true }

      it "works as expected" do
        post = TopicEmbed.import(user, url, title, "some random content")
        expect(post).to be_present

        # It uses regular rendering
        expect(post.cook_method).to eq(Post.cook_methods[:regular])
      end
    end

    context "when importing a topic embed with string tags" do
      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
      fab!(:tag2) { Fabricate(:tag, name: "article") }
      let(:tags) { [tag1.name, tag2.name] }

      it "associates the specified tags with the existing topic" do
        imported_page = TopicEmbed.import(user, url, title, contents, tags: tags)
        expect(imported_page.topic.tags).to match_array([tag1, tag2])
      end
    end

    context "when updating an existing topic embed with string tags" do
      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
      fab!(:tag2) { Fabricate(:tag, name: "article") }
      let(:tags) { [tag1, tag2] }

      before { TopicEmbed.import(user, url, title, contents, tags: [tag1.name]) }

      it "associates the specified tags with the existing topic" do
        imported_page = TopicEmbed.import(user, url, title, contents, tags: tags)
        expect(imported_page.topic.tags).to match_array([tag1, tag2])
      end

      it "does not update tags if tags are nil or unspecified" do
        imported_page = TopicEmbed.import(user, url, title, contents)
        expect(imported_page.topic.tags).to match_array([tag1])
        imported_page = TopicEmbed.import(user, url, title, contents, tags: nil)
        expect(imported_page.topic.tags).to match_array([tag1])
      end

      it "does update tags if tags are empty" do
        imported_page = TopicEmbed.import(user, url, title, contents, tags: [])
        expect(imported_page.topic.tags).to match_array([])
      end
    end

    context "with specified user and tags" do
      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
      fab!(:tag2) { Fabricate(:tag, name: "article") }

      let!(:new_user) { Fabricate(:user) }
      let(:tags) { [tag1.name, tag2.name] }
      let(:imported_post) { TopicEmbed.import(new_user, url, title, contents, tags: tags) }

      it "assigns the specified user as the author" do
        expect(imported_post.user).to eq(new_user)
      end

      it "associates the specified tags with the topic" do
        expect(imported_post.topic.tags).to contain_exactly(tag1, tag2)
      end
    end

    context "when the embeddable host specifies the user and tags" do
      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
      fab!(:tag2) { Fabricate(:tag, name: "article") }
      fab!(:embeddable_host) { Fabricate(:embeddable_host, host: "tag-eviltrout.com") }

      let!(:new_user) { Fabricate(:user) }
      let(:tags) { [tag1.name, tag2.name] }
      let(:embed_url_with_tags) { "http://tag-eviltrout.com/abcd" }

      let(:imported_post) do
        # passing user = system and tags = nil to ensure we're getting the user and tags from the embeddable host
        # and not from the TopicEmbed.import method in the tests
        TopicEmbed.import(Discourse.system_user, embed_url_with_tags, title, contents, tags: nil)
      end

      before do
        embeddable_host.user = new_user
        embeddable_host.tags = [tag1, tag2]
        embeddable_host.save!
      end

      it "assigns the specified user as the author" do
        expect(imported_post.user).to eq(new_user)
      end

      it "associates the specified tags with the topic" do
        expect(imported_post.topic.tags).to contain_exactly(tag1, tag2)
      end
    end

    context "when updating an existing post with new tags and a different user" do
      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
      fab!(:tag2) { Fabricate(:tag, name: "article") }

      let!(:admin) { Fabricate(:admin) }
      let!(:new_admin) { Fabricate(:admin) }
      let(:tags) { [tag1.name, tag2.name] }

      before { SiteSetting.tagging_enabled = true }

      it "updates the user and adds new tags" do
        original_post = TopicEmbed.import(admin, url, title, contents)

        expect(original_post.user).to eq(admin)
        expect(original_post.topic.tags).to be_empty

        embeddable_host.update!(
          tags: [tag1, tag2],
          user: new_admin,
          category: category,
          host: "eviltrout.com",
        )

        edited_post = TopicEmbed.import(admin, url, title, contents)

        expect(edited_post.user).to eq(new_admin)
        expect(edited_post.topic.tags).to match_array([tag1, tag2])
      end
    end

    describe "embedded content truncation" do
      MAX_LENGTH_BEFORE_TRUNCATION = 100

      let(:long_content) { "<p>#{"a" * MAX_LENGTH_BEFORE_TRUNCATION}</p>\n<p>more</p>" }

      it "truncates the imported post when truncation is enabled" do
        SiteSetting.embed_truncate = true
        post = TopicEmbed.import(user, url, title, long_content)

        expect(post.raw).not_to include(long_content)
      end

      it "keeps everything in the imported post when truncation is disabled" do
        SiteSetting.embed_truncate = false
        post = TopicEmbed.import(user, url, title, long_content)

        expect(post.raw).to include(long_content)
      end

      it "looks at first div when there is no paragraph" do
        no_para = "<div><h>testing it</h></div>"

        SiteSetting.embed_truncate = true
        post = TopicEmbed.import(user, url, title, no_para)

        expect(post.raw).to include("testing it")
      end
    end
  end

  describe ".topic_id_for_embed" do
    it "returns correct topic id irrespective of url protocol" do
      topic_embed = Fabricate(:topic_embed, embed_url: "http://example.com/post/248")

      expect(TopicEmbed.topic_id_for_embed("http://exAMPle.com/post/248")).to eq(
        topic_embed.topic_id,
      )
      expect(TopicEmbed.topic_id_for_embed("https://example.com/post/248/")).to eq(
        topic_embed.topic_id,
      )

      expect(TopicEmbed.topic_id_for_embed("http://example.com/post/248/2")).to eq(nil)
      expect(TopicEmbed.topic_id_for_embed("http://examples.com/post/248")).to eq(nil)
      expect(TopicEmbed.topic_id_for_embed("http://example.com/post/24")).to eq(nil)
      expect(TopicEmbed.topic_id_for_embed("http://example.com/post")).to eq(nil)
    end

    it "finds the topic id when the embed_url contains a query string" do
      topic_embed = Fabricate(:topic_embed, embed_url: "http://example.com/post/248?key=foo")
      expect(TopicEmbed.topic_id_for_embed("http://example.com/post/248?key=foo")).to eq(
        topic_embed.topic_id,
      )
    end
  end

  describe ".find_remote" do
    fab!(:embeddable_host)

    describe ".title_scrub" do
      let(:url) { "http://eviltrout.com/123" }
      let(:contents) do
        "<title>Through the Looking Glass - Classic Books</title><body>some content here</body>"
      end

      before { stub_request(:get, url).to_return(status: 200, body: contents) }

      it "doesn't scrub the title by default" do
        response = TopicEmbed.find_remote(url)
        expect(response.title).to eq("Through the Looking Glass - Classic Books")
      end

      it "scrubs the title when the option is enabled" do
        SiteSetting.embed_title_scrubber = " - Classic Books$"
        response = TopicEmbed.find_remote(url)
        expect(response.title).to eq("Through the Looking Glass")
      end

      it "doesn't follow redirect when making request" do
        FinalDestination.any_instance.stubs(:resolve).returns(URI("https://redirect.com"))
        stub_request(:get, "https://redirect.com/").to_return(
          status: 301,
          body: "<title>Moved permanently</title>",
          headers: {
            "Location" => "https://www.example.org/",
          },
        )
        response = TopicEmbed.find_remote(url)
        expect(response.title).to eq("Moved permanently")
      end
    end

    context 'with post with allowed classes "foo" and "emoji"' do
      fab!(:user)
      let(:url) { "http://eviltrout.com/123" }
      let(:contents) do
        "my normal size emoji <p class='foo'>Hi</p> <img class='emoji other foo' src='/images/smiley.jpg'>"
      end

      before do
        SiteSetting.allowed_embed_classnames = "emoji, foo"
        stub_request(:get, url).to_return(status: 200, body: contents)
        @response = TopicEmbed.find_remote(url)
      end

      it "has no author tag" do
        expect(@response.author).to be_blank
      end

      it "img node has emoji class" do
        expect(@response.body).to have_tag("img", with: { class: "emoji" })
      end

      it "img node has foo class" do
        expect(@response.body).to have_tag("img", with: { class: "foo" })
      end

      it "p node has foo class" do
        expect(@response.body).to have_tag("p", with: { class: "foo" })
      end

      it "nodes removes classes other than emoji" do
        expect(@response.body).to have_tag("img", without: { class: "other" })
      end
    end

    context "with post with author metadata" do
      fab!(:user) { Fabricate(:user, username: "eviltrout") }
      let(:url) { "http://eviltrout.com/321" }
      let(:contents) do
        '<html><head><meta name="author" content="eviltrout"></head><body>rich and morty</body></html>'
      end

      before(:each) { stub_request(:get, url).to_return(status: 200, body: contents) }

      it "has no author tag" do
        response = TopicEmbed.find_remote(url)

        expect(response.author).to eq(user)
      end
    end

    context "with post with no allowed classes" do
      fab!(:user)
      let(:url) { "http://eviltrout.com/123" }
      let(:contents) do
        "my normal size emoji <p class='foo'>Hi</p> <img class='emoji other foo' src='/images/smiley.jpg'>"
      end

      before(:each) do
        SiteSetting.allowed_embed_classnames = ""
        stub_request(:get, url).to_return(status: 200, body: contents)
        @response = TopicEmbed.find_remote(url)
      end

      it 'img node doesn\'t have emoji class' do
        expect(@response.body).to have_tag("img", without: { class: "emoji" })
      end

      it 'img node doesn\'t have foo class' do
        expect(@response.body).to have_tag("img", without: { class: "foo" })
      end

      it 'p node doesn\'t foo class' do
        expect(@response.body).to have_tag("p", without: { class: "foo" })
      end

      it 'img node doesn\'t have other class' do
        expect(@response.body).to have_tag("img", without: { class: "other" })
      end
    end

    context "with non-ascii URL" do
      let(:url) { "http://eviltrout.com/test/ماهی" }
      let(:contents) { "<title>سلام</title><body>این یک پاراگراف آزمون است.</body>" }

      before { stub_request(:get, url).to_return(status: 200, body: contents) }

      it "doesn't throw an error" do
        response = TopicEmbed.find_remote(url)
        expect(response.title).to eq("سلام")
      end
    end

    context "with encoded URL" do
      let(:url) { "http://example.com/hello%20world" }
      let(:contents) { "<title>Hello World!</title><body></body>" }

      before { stub_request(:get, url).to_return(status: 200, body: contents) }

      it "doesn't throw an error" do
        response = TopicEmbed.find_remote(url)
        expect(response.title).to eq("Hello World!")
      end
    end

    context "with non-http URL" do
      it "throws an error" do
        url = "/test.txt"

        expect(TopicEmbed.find_remote(url)).to be_nil
      end
    end

    context "with emails" do
      let(:url) { "http://example.com/foo" }
      let(:contents) do
        '<p><a href="mailto:foo%40example.com">URL encoded @ symbol</a></p><p><a href="mailto:bar@example.com">normal mailto link</a></p>'
      end

      before { stub_request(:get, url).to_return(status: 200, body: contents) }

      it "handles mailto links" do
        response = TopicEmbed.find_remote(url)

        expect(response.body).to have_tag("a", with: { href: "mailto:foo@example.com" })
        expect(response.body).to have_tag("a", with: { href: "mailto:bar@example.com" })
      end
    end

    context "with malformed href" do
      let(:url) { "http://example.com/foo" }
      let(:contents) { '<p><a href="(http://foo.bar)">Baz</a></p>' }

      before { stub_request(:get, url).to_return(status: 200, body: contents) }

      it "doesn’t raise an exception" do
        expect { TopicEmbed.find_remote(url) }.not_to raise_error
      end
    end

    context "with canonical links" do
      fab!(:user)
      let(:title) { "How to turn a fish from good to evil in 30 seconds" }
      let(:url) { "http://eviltrout.com/123?asd" }
      let(:canonical_url) { "http://eviltrout.com/123" }
      let(:url2) { "http://eviltrout.com/blog?post=1&canonical=false" }
      let(:canonical_url2) { "http://eviltrout.com/blog?post=1" }
      let(:content) { "<head><link rel=\"canonical\" href=\"#{canonical_url}\"></head>" }
      let(:content2) { "<head><link rel=\"canonical\" href=\"#{canonical_url2}\"></head>" }
      let(:canonical_content) { "<title>Canonical</title><body></body>" }

      before do
        stub_request(:get, url).to_return(status: 200, body: content)
        stub_request(:head, canonical_url)
        stub_request(:get, canonical_url).to_return(status: 200, body: canonical_content)

        stub_request(:get, url2).to_return(status: 200, body: content2)
        stub_request(:head, canonical_url2)
        stub_request(:get, canonical_url2).to_return(status: 200, body: canonical_content)
      end

      it "fetches canonical content" do
        response = TopicEmbed.find_remote(url)

        expect(response.title).to eq("Canonical")
        expect(response.url).to eq(canonical_url)
      end

      it "does not create duplicate topics when url differs from canonical_url" do
        Jobs.run_immediately!
        expect { TopicEmbed.import_remote(canonical_url, { title: title, user: user }) }.to change {
          Topic.all.count
        }.by(1)

        expect { TopicEmbed.import_remote(url, { title: title, user: user }) }.to_not change {
          Topic.all.count
        }
      end

      it "does not create duplicate topics when url contains extra params" do
        Jobs.run_immediately!
        expect {
          TopicEmbed.import_remote(canonical_url2, { title: title, user: user })
        }.to change { Topic.all.count }.by(1)

        expect { TopicEmbed.import_remote(url2, { title: title, user: user }) }.to_not change {
          Topic.all.count
        }
      end
    end
  end

  describe ".absolutize_urls" do
    it "handles badly formed URIs" do
      invalid_url = "http://source.com/#double#anchor"
      contents = "hello world new post <a href='/hello'>hello</a>"

      raw = TopicEmbed.absolutize_urls(invalid_url, contents)
      expect(raw).to eq("hello world new post <a href=\"http://source.com/hello\">hello</a>")
    end

    it "handles malformed links" do
      url = "https://somesource.com"

      contents = <<~HTML
        hello world new post <a href="mailto:somemail@somewhere.org>">hello</a>
        some image <img src="https:/><invalidimagesrc/">
      HTML

      raw = TopicEmbed.absolutize_urls(url, contents)
      expect(raw).to eq(contents)
    end
  end

  describe ".imported_from_html" do
    after { I18n.reload! }

    it "uses the default site locale for the 'imported_from' footer" do
      TranslationOverride.upsert!(
        "en",
        "embed.imported_from",
        "English translation of embed.imported_from with %{link}",
      )
      TranslationOverride.upsert!(
        "de",
        "embed.imported_from",
        "German translation of embed.imported_from with %{link}",
      )

      I18n.locale = :en
      expected_html = TopicEmbed.imported_from_html("some_url")

      I18n.locale = :de
      expect(TopicEmbed.imported_from_html("some_url")).to eq(expected_html)
    end

    it "normalize_encodes the url" do
      html =
        TopicEmbed.imported_from_html(
          'http://www.discourse.org/%23<%2Fa><img%20src%3Dx%20onerror%3Dalert("document.domain")%3B>',
        )
      expected_html =
        "\n<hr>\n<small>This is a companion discussion topic for the original entry at <a href='http://www.discourse.org/%23%3C/a%3E%3Cimg%20src=x%20onerror=alert(%22document.domain%22);%3E'>http://www.discourse.org/%23%3C/a%3E%3Cimg%20src=x%20onerror=alert(%22document.domain%22);%3E</a></small>\n"
      expect(html).to eq(expected_html)
    end
  end

  describe ".expanded_for" do
    fab!(:user)
    let(:title) { "How to turn a fish from good to evil in 30 seconds" }
    let(:url) { "http://eviltrout.com/123" }
    let(:contents) { "<p>hello world new post :D</p>" }
    fab!(:embeddable_host)
    fab!(:category)
    fab!(:tag)

    it "returns embed content" do
      stub_request(:get, url).to_return(status: 200, body: contents)
      post = TopicEmbed.import(user, url, title, contents)
      expect(TopicEmbed.expanded_for(post)).to include(contents)
    end

    it "updates the embed content cache" do
      stub_request(:get, url)
        .to_return(status: 200, body: contents)
        .then
        .to_return(status: 200, body: "contents changed")
      post = TopicEmbed.import(user, url, title, contents)
      TopicEmbed.expanded_for(post)
      expect(post.topic.topic_embed.reload.embed_content_cache).to include("contents changed")
    end
  end
end
-												DEV: use #frozen_string_literal: true on all spec

This change both speeds up specs (less strings to allocate) and helps catch
cases where methods in Discourse are mutating inputs.

Overall we will be migrating everything to use #frozen_string_literal: true
it will take a while, but this is the first and safest move in this direction

											
										
										
											2019-04-29 20:27:42 -04:00
+								# frozen_string_literal: true
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								require "stringio"
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
-												Add RSpec 4 compatibility (#17652)

* Remove outdated option

https://github.com/rspec/rspec-core/commit/04078317ba6577699d06cf4dccf014254dcde7a6

* Use the non-globally exposed RSpec syntax

https://github.com/rspec/rspec-core/pull/2803

* Use the non-globally exposed RSpec syntax, cont

https://github.com/rspec/rspec-core/pull/2803

* Comply to strict predicate matchers

See:
 - https://github.com/rspec/rspec-expectations/pull/1195
 - https://github.com/rspec/rspec-expectations/pull/1196
 - https://github.com/rspec/rspec-expectations/pull/1277

											
										
										
											2022-07-27 22:27:38 -04:00
+								RSpec.describe TopicEmbed do
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								  it { is_expected.to belong_to :topic }
 								  it { is_expected.to belong_to :post }
 								  it { is_expected.to validate_presence_of :embed_url }
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
-												DEV: Use `describe` for methods in specs

											
										
										
											2022-07-27 06:21:10 -04:00
+								  describe ".import" do
-												DEV: Convert min_trust_level_to_tag_topics to groups (#25273)

We're changing the implementation of trust levels to use groups. Part of this is to have site settings that reference trust levels use groups instead. It converts the min_trust_level_to_tag_topics site setting to tag_topic_allowed_groups.
											
										
										
											2024-01-26 00:25:03 -05:00
+								    fab!(:user) { Fabricate(:user, refresh_auto_groups: true) }
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								    let(:title) { "How to turn a fish from good to evil in 30 seconds" }
 								    let(:url) { "http://eviltrout.com/123" }
-												FIX: Convert URLs embedded topics to absolute form (#14975)

Sometimes the expanded post contained broken relative URLs because they
were not converted to their absolute form.
											
										
										
											2021-11-17 00:39:49 -05:00
+								    let(:contents) do
 								      "<p>hello world new post <a href='/hello'>hello</a> <img src='images/wat.jpg'></p>"
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
+								    end
-												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!(:embeddable_host)
 								    fab!(:category)
 								    fab!(:tag)
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
 								    it "returns nil when the URL is malformed" do
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								      expect(TopicEmbed.import(user, "invalid url", title, contents)).to eq(nil)
 								      expect(TopicEmbed.count).to eq(0)
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								    end
-												FIX: Disallow table cells to be weighted actual articles can be main content (#27508)

For Topic Embeds, we would prefer <article> to be the main article in a topic, rather than a table cell <td> with potentially a lot of data. However, in an example URL like here, the table cell (the very large code snippet) is seen as the Topic Embed's article due to the determined content weight by the Readability library we use.

In the newly released 0.7.1 cantino/ruby-readability#94, the library has a new option to exclude the library's default <td> element into content weighting. This is more in line with the original library where they only weighted <p>. So this PR excludes the td, as seen in the tests, to allow the actual article to be seen as the article. This PR also adds the details tag into the allow-list.
											
										
										
											2024-06-18 21:50:49 -04:00
+								    it "Allows figure, figcaption, details HTML tags" do
-												FEATURE: add support for figure and figcaption tags in embeddings (#21276)

Many blog posts use these to illustrate and images were previously omitted

Additionally strip superfluous HTML and BODY tags from embed HTML.

This was incorrectly returned from server.
											
										
										
											2023-04-27 05:57:06 -04:00
+								      html = <<~HTML
 								        <html>
 								        <head>
 								           <title>Some title</title>
 								        </head>
 								        <body>
 								          <div class='content'>
 								            <p>some content</p>
 								            <figure>
 								              <img src="/a.png">
 								              <figcaption>Some caption</figcaption>
-												FIX: Disallow table cells to be weighted actual articles can be main content (#27508)

For Topic Embeds, we would prefer <article> to be the main article in a topic, rather than a table cell <td> with potentially a lot of data. However, in an example URL like here, the table cell (the very large code snippet) is seen as the Topic Embed's article due to the determined content weight by the Readability library we use.

In the newly released 0.7.1 cantino/ruby-readability#94, the library has a new option to exclude the library's default <td> element into content weighting. This is more in line with the original library where they only weighted <p>. So this PR excludes the td, as seen in the tests, to allow the actual article to be seen as the article. This PR also adds the details tag into the allow-list.
											
										
										
											2024-06-18 21:50:49 -04:00
+								            </figure>
 								            <details>
 								              some details
 								            </details>
-												FEATURE: add support for figure and figcaption tags in embeddings (#21276)

Many blog posts use these to illustrate and images were previously omitted

Additionally strip superfluous HTML and BODY tags from embed HTML.

This was incorrectly returned from server.
											
										
										
											2023-04-27 05:57:06 -04:00
+								          </div>
 								        </body>
 								        </html>
 								      HTML
 								      parsed = TopicEmbed.parse_html(html, "https://blog.discourse.com/somepost.html")
 								      # div inception is inserted by the readability gem
 								      expected = <<~HTML
 								        <div><div>
 								          <div>
 								            <p>some content</p>
 								            <figure>
 								              <img src="https://blog.discourse.com/a.png">
 								              <figcaption>Some caption</figcaption>
-												FIX: Disallow table cells to be weighted actual articles can be main content (#27508)

For Topic Embeds, we would prefer <article> to be the main article in a topic, rather than a table cell <td> with potentially a lot of data. However, in an example URL like here, the table cell (the very large code snippet) is seen as the Topic Embed's article due to the determined content weight by the Readability library we use.

In the newly released 0.7.1 cantino/ruby-readability#94, the library has a new option to exclude the library's default <td> element into content weighting. This is more in line with the original library where they only weighted <p>. So this PR excludes the td, as seen in the tests, to allow the actual article to be seen as the article. This PR also adds the details tag into the allow-list.
											
										
										
											2024-06-18 21:50:49 -04:00
+								            </figure>
 								            <details>
 								              some details
 								            </details>
 								          </div>
-												FEATURE: add support for figure and figcaption tags in embeddings (#21276)

Many blog posts use these to illustrate and images were previously omitted

Additionally strip superfluous HTML and BODY tags from embed HTML.

This was incorrectly returned from server.
											
										
										
											2023-04-27 05:57:06 -04:00
+								        </div></div>
 								      HTML
 								      expect(parsed.body.strip).to eq(expected.strip)
 								    end
-												FIX: Disallow table cells to be weighted actual articles can be main content (#27508)

For Topic Embeds, we would prefer <article> to be the main article in a topic, rather than a table cell <td> with potentially a lot of data. However, in an example URL like here, the table cell (the very large code snippet) is seen as the Topic Embed's article due to the determined content weight by the Readability library we use.

In the newly released 0.7.1 cantino/ruby-readability#94, the library has a new option to exclude the library's default <td> element into content weighting. This is more in line with the original library where they only weighted <p>. So this PR excludes the td, as seen in the tests, to allow the actual article to be seen as the article. This PR also adds the details tag into the allow-list.
											
										
										
											2024-06-18 21:50:49 -04:00
+								    # ideally, articles get a heavier weightage than td elements
 								    # so to force that, we do not allow td elements to be scored
 								    it "does not score td tags" do
 								      html = <<~HTML
 								        <html>
 								        <head>
 								           <title>Some title</title>
 								        </head>
 								        <body>
 								          <article>
 								            article content
 								            <table>
 								              <tr>
 								                <td>
 								                  <p>cats</p>
 								                  <p>cats</p>
 								                </td>
 								              </tr>
 								            </table>
 								          </article>
 								        </body>
 								        </html>
 								      HTML
 								      parsed = TopicEmbed.parse_html(html, "https://blog.discourse.com/somepost.html")
 								      expected = <<-HTML
 								        <div><div>
 								    article content
 								          cats
 								          cats
 								</div></div>
 								      HTML
 								      expect(parsed.body.strip).to eq(expected.strip)
 								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "when creating a post" do
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								      let!(:post) { TopicEmbed.import(user, url, title, contents) }
-												DEV: Update test case for `TopicEmbed`.

											
										
										
											2018-08-23 21:41:54 -04:00
+								      let(:topic_embed) { TopicEmbed.find_by(post: post) }
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
 								      it "works as expected with a new URL" do
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								        expect(post).to be_present
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
 								        # It uses raw_html rendering
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								        expect(post.cook_method).to eq(Post.cook_methods[:raw_html])
 								        expect(post.cooked).to eq(post.raw)
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
 								        # It converts relative URLs to absolute
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								        expect(post.cooked).to have_tag("a", with: { href: "http://eviltrout.com/hello" })
 								        expect(post.cooked).to have_tag("img", with: { src: "http://eviltrout.com/images/wat.jpg" })
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
-												FEATURE: Cache embed contents in the database (#25133)

* FEATURE: Cache embed contents in the database

This will be useful for features that rely on the semantic content of topics, like the many AI features



Co-authored-by: Roman Rizzi <rizziromanalejandro@gmail.com>
											
										
										
											2024-01-05 08:09:31 -05:00
+								        # It caches the embed content
 								        expect(post.topic.topic_embed.embed_content_cache).to eq(contents)
-												FIX: Convert URLs embedded topics to absolute form (#14975)

Sometimes the expanded post contained broken relative URLs because they
were not converted to their absolute form.
											
										
										
											2021-11-17 00:39:49 -05:00
+								        # It converts relative URLs to absolute when expanded
 								        stub_request(:get, url).to_return(status: 200, body: contents)
 								        expect(TopicEmbed.expanded_for(post)).to have_tag(
 								          "img",
 								          with: {
 								            src: "http://eviltrout.com/images/wat.jpg",
 								          },
 								        )
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								        expect(post.topic.has_topic_embed?).to eq(true)
 								        expect(TopicEmbed.where(topic_id: post.topic_id)).to be_present
-												FEATURE: Can edit category/host relationships for embedding

											
										
										
											2015-08-18 17:15:46 -04:00
 								        expect(post.topic.category).to eq(embeddable_host.category)
-												Embedded topics are now unlisted by default

Previously this site setting `embed unlisted` defaulted to false and
empty topics would be generated for embed, but those topics tend to take
up a lot of room on the topic lists.

This new default creates invisible topics by default until they receive
their first reply.

											
										
										
											2020-10-01 15:40:13 -04:00
+								        expect(post.topic).not_to be_visible
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								      end
-												FIX: update TopicEmbed's title and user correctly

											
										
										
											2018-08-21 06:19:03 -04:00
+								      it "Supports updating the post content" do
-												DEV: Update test case for `TopicEmbed`.

											
										
										
											2018-08-23 21:41:54 -04:00
+								        expect do
-												FEATURE: Nokogumbo (#9577)

* FEATURE: Nokogumbo

Use Nokogumbo HTML parser.
											
										
										
											2020-05-04 23:46:57 -04:00
+								          TopicEmbed.import(user, url, "New title received", "<p>muhahaha new contents!</p>")
-												DEV: Update test case for `TopicEmbed`.

											
										
										
											2018-08-23 21:41:54 -04:00
+								        end.to change { topic_embed.reload.content_sha1 }
-												FIX: Embedded topics couldn't update their titles

											
										
										
											2020-04-20 14:27:43 -04:00
+								        expect(topic_embed.topic.title).to eq("New title received")
-												FIX: TopicEmbed.import should update title and author

											
										
										
											2018-04-18 15:22:43 -04:00
-												DEV: Update test case for `TopicEmbed`.

											
										
										
											2018-08-23 21:41:54 -04:00
+								        expect(topic_embed.post.cooked).to match(/new contents/)
-												FIX: update TopicEmbed's title and user correctly

											
										
										
											2018-08-21 06:19:03 -04:00
+								      end
 								      it "Supports updating the post author" do
 								        new_user = Fabricate(:user)
-												DEV: Update test case for `TopicEmbed`.

											
										
										
											2018-08-23 21:41:54 -04:00
+								        TopicEmbed.import(new_user, url, title, contents)
-												FIX: update TopicEmbed's title and user correctly

											
										
										
											2018-08-21 06:19:03 -04:00
-												DEV: Update test case for `TopicEmbed`.

											
										
										
											2018-08-23 21:41:54 -04:00
+								        topic_embed.reload
 								        expect(topic_embed.post.user).to eq(new_user)
 								        expect(topic_embed.post.topic.user).to eq(new_user)
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								      end
-												FEATURE: Cache embed contents in the database (#25133)

* FEATURE: Cache embed contents in the database

This will be useful for features that rely on the semantic content of topics, like the many AI features



Co-authored-by: Roman Rizzi <rizziromanalejandro@gmail.com>
											
										
										
											2024-01-05 08:09:31 -05:00
+								      it "Supports updating the embed content cache" do
 								        expect do TopicEmbed.import(user, url, title, "new contents") end.to change {
 								          topic_embed.reload.embed_content_cache
 								        }
 								        expect(topic_embed.embed_content_cache).to eq("new contents")
 								      end
-												Normalize URL from Feed Entry after adding link to original in Topic

Since a URL might be case sensitive, adding a link to the original
Feed Entry with changed case to the Topic could end in 404.

											
										
										
											2014-03-26 23:24:57 -04:00
+								      it "Should leave uppercase Feed Entry URL untouched in content" do
 								        cased_url = "http://eviltrout.com/ABCD"
 								        post = TopicEmbed.import(user, cased_url, title, "some random content")
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								        expect(post.cooked).to match(/#{cased_url}/)
-												Normalize URL from Feed Entry after adding link to original in Topic

Since a URL might be case sensitive, adding a link to the original
Feed Entry with changed case to the Topic could end in 404.

											
										
										
											2014-03-26 23:24:57 -04:00
+								      end
 								      it "Should leave lowercase Feed Entry URL untouched in content" do
 								        cased_url = "http://eviltrout.com/abcd"
 								        post = TopicEmbed.import(user, cased_url, title, "some random content")
-												Update rspec syntax to v3

update rspec syntax to v3

change syntax to rspec v3

oops. fix typo

mailers classes with rspec3 syntax

helpers with rspec3 syntax

jobs with rspec3 syntax

serializers with rspec3 syntax

views with rspec3 syntax

support to rspec3 syntax

category spec with rspec3 syntax

											
										
										
											2014-12-31 09:55:03 -05:00
+								        expect(post.cooked).to match(/#{cased_url}/)
-												Normalize URL from Feed Entry after adding link to original in Topic

Since a URL might be case sensitive, adding a link to the original
Feed Entry with changed case to the Topic could end in 404.

											
										
										
											2014-03-26 23:24:57 -04:00
+								      end
-												FEATURE: New site setting `embed_unlisted` (#9391)

If enabled, posts imported to discourse via embeddings will default to
unlisted until they receive a reply.
											
										
										
											2020-04-13 15:17:02 -04:00
-												DEV: Add `import_embed_unlisted` site setting (#26222)


											
										
										
											2024-03-27 08:57:43 -04:00
+								      shared_examples "topic is unlisted" do
 								        it "unlists the topic until someone replies" do
 								          Jobs.run_immediately!
 								          imported_post =
 								            TopicEmbed.import(user, "http://eviltrout.com/abcd", title, "some random content")
 								          expect(imported_post.topic).not_to be_visible
 								          pc =
 								            PostCreator.new(
 								              Fabricate(:user),
 								              raw: "this is a reply that will make the topic visible",
 								              topic_id: imported_post.topic_id,
 								              reply_to_post_number: 1,
 								            )
 								          pc.create
 								          expect(imported_post.topic.reload).to be_visible
 								        end
-												FEATURE: New site setting `embed_unlisted` (#9391)

If enabled, posts imported to discourse via embeddings will default to
unlisted until they receive a reply.
											
										
										
											2020-04-13 15:17:02 -04:00
+								      end
-												Embedded topics are now unlisted by default

Previously this site setting `embed unlisted` defaulted to false and
empty topics would be generated for embed, but those topics tend to take
up a lot of room on the topic lists.

This new default creates invisible topics by default until they receive
their first reply.

											
										
										
											2020-10-01 15:40:13 -04:00
-												DEV: Add `import_embed_unlisted` site setting (#26222)


											
										
										
											2024-03-27 08:57:43 -04:00
+								      context "when import embed unlisted is true" do
 								        before { SiteSetting.import_embed_unlisted = true }
 								        include_examples "topic is unlisted"
 								        context "when embed unlisted is false" do
 								          before { SiteSetting.embed_unlisted = false }
 								          include_examples "topic is unlisted"
 								        end
 								      end
 								      context "when import embed unlisted is false" do
 								        before { SiteSetting.import_embed_unlisted = false }
 								        context "when embed unlisted is false" do
 								          before { SiteSetting.embed_unlisted = false }
 								          it "lists the topic" do
 								            Jobs.run_immediately!
 								            imported_post =
 								              TopicEmbed.import(user, "http://eviltrout.com/abcd", title, "some random content")
 								            expect(imported_post.topic).to be_visible
 								          end
 								        end
 								        context "when embed unlisted is true" do
 								          before { SiteSetting.embed_unlisted = true }
 								          include_examples "topic is unlisted"
 								        end
-												Embedded topics are now unlisted by default

Previously this site setting `embed unlisted` defaulted to false and
empty topics would be generated for embed, but those topics tend to take
up a lot of room on the topic lists.

This new default creates invisible topics by default until they receive
their first reply.

											
										
										
											2020-10-01 15:40:13 -04:00
+								      end
-												DEV: Allow passing a category parameter when importing a topic (#14069)

This will be used in the rss pooling plugin to address the feature
request at https://meta.discourse.org/t/-/200644?u=falco
											
										
										
											2021-08-17 17:17:07 -04:00
 								      it "creates the topic in the category passed as a parameter" do
 								        Jobs.run_immediately!
 								        imported_post =
 								          TopicEmbed.import(
 								            user,
 								            "http://eviltrout.com/abcd",
 								            title,
 								            "some random content",
 								            category_id: category.id,
 								          )
 								        expect(imported_post.topic.category).not_to eq(embeddable_host.category)
 								        expect(imported_post.topic.category).to eq(category)
 								      end
-												DEV: Allow passing cook_method to TopicEmbed.import to override default (#14209)

DEV: Allow passing cook_method to TopicEmbed.import to override default

This will be used in the rss-polling plugin when we want to have
oneboxes on feed content, like youtube for example.


											
										
										
											2021-09-01 14:46:39 -04:00
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
+								      it "does not create duplicate topics with different protocols in the embed_url" do
 								        Jobs.run_immediately!
 								        expect {
 								          TopicEmbed.import(user, "http://eviltrout.com/abcd", title, "some random content")
 								        }.to change { Topic.all.count }.by(1)
 								        expect {
 								          TopicEmbed.import(user, "https://eviltrout.com/abcd", title, "some random content")
 								        }.to_not change { Topic.all.count }
 								      end
-												DEV: Allow TopicEmbed.import to optionally receive a list of tags (#14301)

This will be used by the rss-polling plugin
											
										
										
											2021-09-13 16:01:59 -04:00
+								      it "creates the topic with the tag passed as a parameter" do
 								        Jobs.run_immediately!
 								        SiteSetting.tagging_enabled = true
 								        imported_post =
 								          TopicEmbed.import(
 								            user,
 								            "http://eviltrout.com/abcd",
 								            title,
 								            "some random content",
 								            tags: [tag.name],
 								          )
 								        expect(imported_post.topic.tags).to include(tag)
 								      end
-												DEV: Allow passing cook_method to TopicEmbed.import to override default (#14209)

DEV: Allow passing cook_method to TopicEmbed.import to override default

This will be used in the rss-polling plugin when we want to have
oneboxes on feed content, like youtube for example.


											
										
										
											2021-09-01 14:46:39 -04:00
+								      it "respects overriding the cook_method when asked" do
 								        Jobs.run_immediately!
 								        SiteSetting.embed_support_markdown = false
 								        stub_request(:get, "https://www.youtube.com/watch?v=K56soYl0U1w").to_return(
 								          status: 200,
 								          body: "",
 								          headers: {
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
+								          },
-												DEV: Allow passing cook_method to TopicEmbed.import to override default (#14209)

DEV: Allow passing cook_method to TopicEmbed.import to override default

This will be used in the rss-polling plugin when we want to have
oneboxes on feed content, like youtube for example.


											
										
										
											2021-09-01 14:46:39 -04:00
+								        )
 								        stub_request(:get, "https://www.youtube.com/embed/K56soYl0U1w").to_return(
 								          status: 200,
 								          body: "",
 								          headers: {
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
+								          },
-												DEV: Allow passing cook_method to TopicEmbed.import to override default (#14209)

DEV: Allow passing cook_method to TopicEmbed.import to override default

This will be used in the rss-polling plugin when we want to have
oneboxes on feed content, like youtube for example.


											
										
										
											2021-09-01 14:46:39 -04:00
+								        )
 								        imported_post =
 								          TopicEmbed.import(
 								            user,
 								            "http://eviltrout.com/abcd",
 								            title,
 								            "https://www.youtube.com/watch?v=K56soYl0U1w",
 								            cook_method: Post.cook_methods[:regular],
 								          )
 								        expect(imported_post.cooked).to match(/onebox|iframe/)
 								      end
-												DEV: Add `topic_embed_import_create_args` plugin modifier (#26527)

* DEV: Add `topic_embed_import_create_args` plugin modifier

This modifier allows a plugin to change the arguments used when creating
 a new topic for an imported article.

For example: let's say you want to prepend "Imported: " to the title of
every imported topic. You could use this modifier like so:

```ruby
# In your plugin's code
plugin.register_modifier(:topic_embed_import_create_args) do |args|
  args[:title] = "Imported: #{args[:title]}"
  args
end
```

In this example, the modifier is prepending "Imported: " to the `title` in the `create_args` hash. This modified title would then be used when the new topic is created.
											
										
										
											2024-04-05 11:37:53 -04:00
 								      describe "topic_embed_import_create_args modifier" do
 								        after { DiscoursePluginRegistry.clear_modifiers! }
 								        it "can alter the args used to create the topic" do
 								          plugin = Plugin::Instance.new
 								          plugin.register_modifier(:topic_embed_import_create_args) do |args|
 								            args[:title] = "MODIFIED: #{args[:title]}"
 								            args
 								          end
 								          Jobs.run_immediately!
 								          imported_post =
 								            TopicEmbed.import(
 								              user,
 								              "http://eviltrout.com/abcd",
 								              title,
 								              "some random content",
 								              category_id: category.id,
 								            )
 								          expect(imported_post.topic.title).to eq("MODIFIED: #{title}")
 								        end
 								        it "will revert to defaults if the modifier returns nil" do
 								          plugin = Plugin::Instance.new
 								          plugin.register_modifier(:topic_embed_import_create_args) { |args| nil }
 								          Jobs.run_immediately!
 								          imported_post =
 								            TopicEmbed.import(
 								              user,
 								              "http://eviltrout.com/abcd",
 								              title,
 								              "some random content",
 								              category_id: category.id,
 								            )
 								          expect(imported_post.topic.title).to eq(title)
 								        end
 								      end
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "when post creation supports markdown rendering" do
-												FEATURE: support markdown rendering for embedded posts

											
										
										
											2018-03-10 21:26:47 -05:00
+								      before { SiteSetting.embed_support_markdown = true }
 								      it "works as expected" do
 								        post = TopicEmbed.import(user, url, title, "some random content")
 								        expect(post).to be_present
 								        # It uses regular rendering
 								        expect(post.cook_method).to eq(Post.cook_methods[:regular])
 								      end
 								    end
-												FIX: Frozen string error in `TopicEmbed.import` (#7938)

When `SiteSetting.embed_truncate` is enabled (by default), the truncated
string is mutatable and does not raise an error.

However, when the setting is disabled, the `contents` string is frozen
and immutable, and will raise a `FrozenError`.
											
										
										
											2019-07-25 09:21:01 -04:00
-												FIX: Topic embedding importer should accept string tags (#27624)

* FIX: Embedding importer should accept string tags
											
										
										
											2024-06-26 12:34:55 -04:00
+								    context "when importing a topic embed with string tags" do
 								      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
 								      fab!(:tag2) { Fabricate(:tag, name: "article") }
 								      let(:tags) { [tag1.name, tag2.name] }
 								      it "associates the specified tags with the existing topic" do
 								        imported_page = TopicEmbed.import(user, url, title, contents, tags: tags)
 								        expect(imported_page.topic.tags).to match_array([tag1, tag2])
 								      end
 								    end
 								    context "when updating an existing topic embed with string tags" do
 								      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
 								      fab!(:tag2) { Fabricate(:tag, name: "article") }
 								      let(:tags) { [tag1, tag2] }
 								      before { TopicEmbed.import(user, url, title, contents, tags: [tag1.name]) }
 								      it "associates the specified tags with the existing topic" do
 								        imported_page = TopicEmbed.import(user, url, title, contents, tags: tags)
 								        expect(imported_page.topic.tags).to match_array([tag1, tag2])
 								      end
-												FIX: topic embed blank tags or passed with nil do not blank out existing topic tags (#27699)

When a topic embed is run with either no tags argument or a nil tag argument
this should not affect any existing tags.

Only update topic tags when tags argument is explicitly empty.
											
										
										
											2024-07-03 17:50:59 -04:00
 								      it "does not update tags if tags are nil or unspecified" do
 								        imported_page = TopicEmbed.import(user, url, title, contents)
 								        expect(imported_page.topic.tags).to match_array([tag1])
 								        imported_page = TopicEmbed.import(user, url, title, contents, tags: nil)
 								        expect(imported_page.topic.tags).to match_array([tag1])
 								      end
 								      it "does update tags if tags are empty" do
 								        imported_page = TopicEmbed.import(user, url, title, contents, tags: [])
 								        expect(imported_page.topic.tags).to match_array([])
 								      end
-												FIX: Topic embedding importer should accept string tags (#27624)

* FIX: Embedding importer should accept string tags
											
										
										
											2024-06-26 12:34:55 -04:00
+								    end
-												FEATURE: Extend embeddable hosts with Individual tags and author assignments (#26868)

* FEATURE: Extend embeddable hosts with tags and author assignments
											
										
										
											2024-05-16 15:47:01 -04:00
+								    context "with specified user and tags" do
 								      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
 								      fab!(:tag2) { Fabricate(:tag, name: "article") }
 								      let!(:new_user) { Fabricate(:user) }
 								      let(:tags) { [tag1.name, tag2.name] }
 								      let(:imported_post) { TopicEmbed.import(new_user, url, title, contents, tags: tags) }
 								      it "assigns the specified user as the author" do
 								        expect(imported_post.user).to eq(new_user)
 								      end
 								      it "associates the specified tags with the topic" do
 								        expect(imported_post.topic.tags).to contain_exactly(tag1, tag2)
 								      end
 								    end
-												FIX: Prevent crash importing topics on a tagged embeddable host (#27254)


											
										
										
											2024-05-30 11:04:36 -04:00
+								    context "when the embeddable host specifies the user and tags" do
 								      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
 								      fab!(:tag2) { Fabricate(:tag, name: "article") }
 								      fab!(:embeddable_host) { Fabricate(:embeddable_host, host: "tag-eviltrout.com") }
 								      let!(:new_user) { Fabricate(:user) }
 								      let(:tags) { [tag1.name, tag2.name] }
 								      let(:embed_url_with_tags) { "http://tag-eviltrout.com/abcd" }
 								      let(:imported_post) do
 								        # passing user = system and tags = nil to ensure we're getting the user and tags from the embeddable host
 								        # and not from the TopicEmbed.import method in the tests
 								        TopicEmbed.import(Discourse.system_user, embed_url_with_tags, title, contents, tags: nil)
 								      end
 								      before do
 								        embeddable_host.user = new_user
 								        embeddable_host.tags = [tag1, tag2]
 								        embeddable_host.save!
 								      end
 								      it "assigns the specified user as the author" do
 								        expect(imported_post.user).to eq(new_user)
 								      end
 								      it "associates the specified tags with the topic" do
 								        expect(imported_post.topic.tags).to contain_exactly(tag1, tag2)
 								      end
 								    end
-												FEATURE: Extend embeddable hosts with Individual tags and author assignments (#26868)

* FEATURE: Extend embeddable hosts with tags and author assignments
											
										
										
											2024-05-16 15:47:01 -04:00
+								    context "when updating an existing post with new tags and a different user" do
 								      fab!(:tag1) { Fabricate(:tag, name: "interesting") }
 								      fab!(:tag2) { Fabricate(:tag, name: "article") }
 								      let!(:admin) { Fabricate(:admin) }
 								      let!(:new_admin) { Fabricate(:admin) }
 								      let(:tags) { [tag1.name, tag2.name] }
 								      before { SiteSetting.tagging_enabled = true }
 								      it "updates the user and adds new tags" do
 								        original_post = TopicEmbed.import(admin, url, title, contents)
 								        expect(original_post.user).to eq(admin)
 								        expect(original_post.topic.tags).to be_empty
 								        embeddable_host.update!(
 								          tags: [tag1, tag2],
 								          user: new_admin,
 								          category: category,
 								          host: "eviltrout.com",
 								        )
 								        edited_post = TopicEmbed.import(admin, url, title, contents)
 								        expect(edited_post.user).to eq(new_admin)
 								        expect(edited_post.topic.tags).to match_array([tag1, tag2])
 								      end
 								    end
-												FIX: Frozen string error in `TopicEmbed.import` (#7938)

When `SiteSetting.embed_truncate` is enabled (by default), the truncated
string is mutatable and does not raise an error.

However, when the setting is disabled, the `contents` string is frozen
and immutable, and will raise a `FrozenError`.
											
										
										
											2019-07-25 09:21:01 -04:00
+								    describe "embedded content truncation" do
 								      MAX_LENGTH_BEFORE_TRUNCATION = 100
 								      let(:long_content) { "<p>#{"a" * MAX_LENGTH_BEFORE_TRUNCATION}</p>\n<p>more</p>" }
 								      it "truncates the imported post when truncation is enabled" do
 								        SiteSetting.embed_truncate = true
 								        post = TopicEmbed.import(user, url, title, long_content)
 								        expect(post.raw).not_to include(long_content)
 								      end
 								      it "keeps everything in the imported post when truncation is disabled" do
 								        SiteSetting.embed_truncate = false
 								        post = TopicEmbed.import(user, url, title, long_content)
 								        expect(post.raw).to include(long_content)
 								      end
-												FIX: embedding topics would fail with some HTML

When truncating content we try to search for first paragraph, if HTML had
no P it would fallback to first div which may have nested elements.

											
										
										
											2019-08-06 22:45:55 -04:00
 								      it "looks at first div when there is no paragraph" do
 								        no_para = "<div><h>testing it</h></div>"
 								        SiteSetting.embed_truncate = true
 								        post = TopicEmbed.import(user, url, title, no_para)
 								        expect(post.raw).to include("testing it")
 								      end
-												FIX: Frozen string error in `TopicEmbed.import` (#7938)

When `SiteSetting.embed_truncate` is enabled (by default), the truncated
string is mutatable and does not raise an error.

However, when the setting is disabled, the `contents` string is frozen
and immutable, and will raise a `FrozenError`.
											
										
										
											2019-07-25 09:21:01 -04:00
+								    end
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								  end
-												DEV: Use `describe` for methods in specs

											
										
										
											2022-07-27 06:21:10 -04:00
+								  describe ".topic_id_for_embed" do
-												FIX: do not create duplicate topics

https://meta.discourse.org/t/duplicate-http-https-topics-are-randomly-created/77190

											
										
										
											2018-01-04 13:13:17 -05:00
+								    it "returns correct topic id irrespective of url protocol" do
 								      topic_embed = Fabricate(:topic_embed, embed_url: "http://example.com/post/248")
 								      expect(TopicEmbed.topic_id_for_embed("http://exAMPle.com/post/248")).to eq(
 								        topic_embed.topic_id,
 								      )
 								      expect(TopicEmbed.topic_id_for_embed("https://example.com/post/248/")).to eq(
 								        topic_embed.topic_id,
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
+								      )
-												FIX: do not create duplicate topics

https://meta.discourse.org/t/duplicate-http-https-topics-are-randomly-created/77190

											
										
										
											2018-01-04 13:13:17 -05:00
+								      expect(TopicEmbed.topic_id_for_embed("http://example.com/post/248/2")).to eq(nil)
 								      expect(TopicEmbed.topic_id_for_embed("http://examples.com/post/248")).to eq(nil)
 								      expect(TopicEmbed.topic_id_for_embed("http://example.com/post/24")).to eq(nil)
 								      expect(TopicEmbed.topic_id_for_embed("http://example.com/post")).to eq(nil)
 								    end
-												FIX: Embedded topic was not found when URL contained query string

											
										
										
											2018-02-13 18:28:16 -05:00
 								    it "finds the topic id when the embed_url contains a query string" do
 								      topic_embed = Fabricate(:topic_embed, embed_url: "http://example.com/post/248?key=foo")
 								      expect(TopicEmbed.topic_id_for_embed("http://example.com/post/248?key=foo")).to eq(
 								        topic_embed.topic_id,
 								      )
 								    end
-												FIX: do not create duplicate topics

https://meta.discourse.org/t/duplicate-http-https-topics-are-randomly-created/77190

											
										
										
											2018-01-04 13:13:17 -05:00
+								  end
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								  describe ".find_remote" 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!(:embeddable_host)
-												FEATURE: Ability to scrub titles when importing embeddable content

											
										
										
											2016-08-22 12:43:02 -04:00
-												DEV: Use `describe` for methods in specs

											
										
										
											2022-07-27 06:21:10 -04:00
+								    describe ".title_scrub" do
-												FEATURE: Ability to scrub titles when importing embeddable content

											
										
										
											2016-08-22 12:43:02 -04:00
+								      let(:url) { "http://eviltrout.com/123" }
 								      let(:contents) do
 								        "<title>Through the Looking Glass - Classic Books</title><body>some content here</body>"
 								      end
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								      before { stub_request(:get, url).to_return(status: 200, body: contents) }
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
-												FEATURE: Ability to scrub titles when importing embeddable content

											
										
										
											2016-08-22 12:43:02 -04:00
+								      it "doesn't scrub the title by default" do
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								        response = TopicEmbed.find_remote(url)
 								        expect(response.title).to eq("Through the Looking Glass - Classic Books")
-												FEATURE: Ability to scrub titles when importing embeddable content

											
										
										
											2016-08-22 12:43:02 -04:00
+								      end
 								      it "scrubs the title when the option is enabled" do
 								        SiteSetting.embed_title_scrubber = " - Classic Books$"
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								        response = TopicEmbed.find_remote(url)
 								        expect(response.title).to eq("Through the Looking Glass")
-												FEATURE: Ability to scrub titles when importing embeddable content

											
										
										
											2016-08-22 12:43:02 -04:00
+								      end
-												SECURITY: SSRF vulnerability in TopicEmbed

Block redirects when making the final request in TopicEmbed to prevent Server Side Request Forgery (SSRF)

											
										
										
											2023-10-26 23:02:20 -04:00
 								      it "doesn't follow redirect when making request" do
 								        FinalDestination.any_instance.stubs(:resolve).returns(URI("https://redirect.com"))
 								        stub_request(:get, "https://redirect.com/").to_return(
 								          status: 301,
 								          body: "<title>Moved permanently</title>",
 								          headers: {
 								            "Location" => "https://www.example.org/",
 								          },
 								        )
 								        response = TopicEmbed.find_remote(url)
 								        expect(response.title).to eq("Moved permanently")
 								      end
-												FEATURE: Ability to scrub titles when importing embeddable content

											
										
										
											2016-08-22 12:43:02 -04:00
+								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context 'with post with allowed classes "foo" and "emoji"' 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!(:user)
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      let(:url) { "http://eviltrout.com/123" }
 								      let(:contents) do
 								        "my normal size emoji <p class='foo'>Hi</p> <img class='emoji other foo' src='/images/smiley.jpg'>"
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
+								      end
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
-												Nuke all `SiteSetting.stubs` from our codebase.

											
										
										
											2017-07-07 02:09:14 -04:00
+								      before do
-												FIX: use allowlist and blocklist terminology (#10209)

This is a PR of the renaming whitelist to allowlist and blacklist to the blocklist.
											
										
										
											2020-07-26 20:23:54 -04:00
+								        SiteSetting.allowed_embed_classnames = "emoji, foo"
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								        stub_request(:get, url).to_return(status: 200, body: contents)
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        @response = TopicEmbed.find_remote(url)
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								      end
 								      it "has no author tag" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.author).to be_blank
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it "img node has emoji class" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("img", with: { class: "emoji" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it "img node has foo class" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("img", with: { class: "foo" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it "p node has foo class" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("p", with: { class: "foo" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it "nodes removes classes other than emoji" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("img", without: { class: "other" })
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								      end
 								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with post with author metadata" do
-												DEV: Prefabrication (test optimization) (#7414)

* Introduced fab!, a helper that creates database state for a group

It's almost identical to let_it_be, except:

 1. It creates a new object for each test by default,
 2. You can disable it using PREFABRICATION=0


											
										
										
											2019-05-06 23:12:20 -04:00
+								      fab!(:user) { Fabricate(:user, username: "eviltrout") }
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								      let(:url) { "http://eviltrout.com/321" }
 								      let(:contents) do
 								        '<html><head><meta name="author" content="eviltrout"></head><body>rich and morty</body></html>'
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								      before(:each) { stub_request(:get, url).to_return(status: 200, body: contents) }
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								      it "has no author tag" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        response = TopicEmbed.find_remote(url)
-												FEATURE: Support author meta tags for embedding

											
										
										
											2016-08-30 12:01:04 -04:00
+								        expect(response.author).to eq(user)
 								      end
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with post with no allowed classes" 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!(:user)
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      let(:url) { "http://eviltrout.com/123" }
 								      let(:contents) do
 								        "my normal size emoji <p class='foo'>Hi</p> <img class='emoji other foo' src='/images/smiley.jpg'>"
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
+								      end
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
 								      before(:each) do
-												FIX: use allowlist and blocklist terminology (#10209)

This is a PR of the renaming whitelist to allowlist and blacklist to the blocklist.
											
										
										
											2020-07-26 20:23:54 -04:00
+								        SiteSetting.allowed_embed_classnames = ""
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								        stub_request(:get, url).to_return(status: 200, body: contents)
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        @response = TopicEmbed.find_remote(url)
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it 'img node doesn\'t have emoji class' do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("img", without: { class: "emoji" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it 'img node doesn\'t have foo class' do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("img", without: { class: "foo" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it 'p node doesn\'t foo class' do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("p", without: { class: "foo" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
 								      it 'img node doesn\'t have other class' do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        expect(@response.body).to have_tag("img", without: { class: "other" })
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								      end
-												FIX: More errors with non-ascii URLs

											
										
										
											2017-03-07 11:21:26 -05:00
+								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with non-ascii URL" do
-												FIX: More errors with non-ascii URLs

											
										
										
											2017-03-07 11:21:26 -05:00
+								      let(:url) { "http://eviltrout.com/test/ماهی" }
 								      let(:contents) { "<title>سلام</title><body>این یک پاراگراف آزمون است.</body>" }
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								      before { stub_request(:get, url).to_return(status: 200, body: contents) }
-												FIX: More errors with non-ascii URLs

											
										
										
											2017-03-07 11:21:26 -05:00
 								      it "doesn't throw an error" do
 								        response = TopicEmbed.find_remote(url)
 								        expect(response.title).to eq("سلام")
 								      end
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with encoded URL" do
-												FIX: do not escape already escaped chars in URL

											
										
										
											2017-09-22 11:36:44 -04:00
+								      let(:url) { "http://example.com/hello%20world" }
 								      let(:contents) { "<title>Hello World!</title><body></body>" }
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								      before { stub_request(:get, url).to_return(status: 200, body: contents) }
-												FIX: do not escape already escaped chars in URL

											
										
										
											2017-09-22 11:36:44 -04:00
 								      it "doesn't throw an error" do
 								        response = TopicEmbed.find_remote(url)
 								        expect(response.title).to eq("Hello World!")
 								      end
 								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with non-http URL" do
-												Revert "Revert "Merge branch 'master' of https://github.com/discourse/discourse""

This reverts commit 20780a1eeed56b321daf18ee6bbfe681a51d1bf4.

* SECURITY: re-adds accidentally reverted commit:
  03d26cd6: ensure embed_url contains valid http(s) uri
* when the merge commit e62a85cf was reverted, git chose the 2660c2e2 parent to land on
  instead of the 03d26cd6 parent (which contains security fixes)

											
										
										
											2020-05-23 00:56:13 -04:00
+								      it "throws an error" do
-												FIX: Don't raise an exception if a topic cannot be retrieved (#9906)


											
										
										
											2020-05-28 10:59:20 -04:00
+								        url = "/test.txt"
 								        expect(TopicEmbed.find_remote(url)).to be_nil
-												Revert "Revert "Merge branch 'master' of https://github.com/discourse/discourse""

This reverts commit 20780a1eeed56b321daf18ee6bbfe681a51d1bf4.

* SECURITY: re-adds accidentally reverted commit:
  03d26cd6: ensure embed_url contains valid http(s) uri
* when the merge commit e62a85cf was reverted, git chose the 2660c2e2 parent to land on
  instead of the 03d26cd6 parent (which contains security fixes)

											
										
										
											2020-05-23 00:56:13 -04:00
+								      end
 								    end
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with emails" do
-												FIX: handle URL encoded email addresses

											
										
										
											2017-09-22 08:26:06 -04:00
+								      let(:url) { "http://example.com/foo" }
 								      let(:contents) do
 								        '<p><a href="mailto:foo%40example.com">URL encoded @ symbol</a></p><p><a href="mailto:bar@example.com">normal mailto link</a></p>'
 								      end
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								      before { stub_request(:get, url).to_return(status: 200, body: contents) }
-												DEV: Apply syntax_tree formatting to `spec/*`

											
										
										
											2023-01-09 06:18:21 -05:00
-												FIX: handle URL encoded email addresses

											
										
										
											2017-09-22 08:26:06 -04:00
+								      it "handles mailto links" do
 								        response = TopicEmbed.find_remote(url)
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
-												FIX: Convert URLs embedded topics to absolute form (#14975)

Sometimes the expanded post contained broken relative URLs because they
were not converted to their absolute form.
											
										
										
											2021-11-17 00:39:49 -05:00
+								        expect(response.body).to have_tag("a", with: { href: "mailto:foo@example.com" })
-												FIX: handle URL encoded email addresses

											
										
										
											2017-09-22 08:26:06 -04:00
+								        expect(response.body).to have_tag("a", with: { href: "mailto:bar@example.com" })
 								      end
 								    end
-												FIX: prevents malformed href to crash TopicEmbed (#12910)

If the associated page of a remote url passed to `TopicEmber.new(remote_url)` contained a malformed link like: `<a href="(http://foo.bar)">Baz</a>` it would raise an uncaught exception:

```
Job exception: Invalid scheme format: (http
```
											
										
										
											2021-04-30 05:10:19 -04:00
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with malformed href" do
-												FIX: prevents malformed href to crash TopicEmbed (#12910)

If the associated page of a remote url passed to `TopicEmber.new(remote_url)` contained a malformed link like: `<a href="(http://foo.bar)">Baz</a>` it would raise an uncaught exception:

```
Job exception: Invalid scheme format: (http
```
											
										
										
											2021-04-30 05:10:19 -04:00
+								      let(:url) { "http://example.com/foo" }
 								      let(:contents) { '<p><a href="(http://foo.bar)">Baz</a></p>' }
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								      before { stub_request(:get, url).to_return(status: 200, body: contents) }
-												FIX: prevents malformed href to crash TopicEmbed (#12910)

If the associated page of a remote url passed to `TopicEmber.new(remote_url)` contained a malformed link like: `<a href="(http://foo.bar)">Baz</a>` it would raise an uncaught exception:

```
Job exception: Invalid scheme format: (http
```
											
										
										
											2021-04-30 05:10:19 -04:00
 								      it "doesn’t raise an exception" do
 								        expect { TopicEmbed.find_remote(url) }.not_to raise_error
 								      end
 								    end
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
-												DEV: Use proper wording for contexts in specs

											
										
										
											2022-07-27 12:14:14 -04:00
+								    context "with canonical links" 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!(:user)
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
+								      let(:title) { "How to turn a fish from good to evil in 30 seconds" }
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								      let(:url) { "http://eviltrout.com/123?asd" }
 								      let(:canonical_url) { "http://eviltrout.com/123" }
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
+								      let(:url2) { "http://eviltrout.com/blog?post=1&canonical=false" }
 								      let(:canonical_url2) { "http://eviltrout.com/blog?post=1" }
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								      let(:content) { "<head><link rel=\"canonical\" href=\"#{canonical_url}\"></head>" }
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
+								      let(:content2) { "<head><link rel=\"canonical\" href=\"#{canonical_url2}\"></head>" }
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								      let(:canonical_content) { "<title>Canonical</title><body></body>" }
 								      before do
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								        stub_request(:get, url).to_return(status: 200, body: content)
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        stub_request(:head, canonical_url)
-												DEV: Fix rubocop issues (#14715)


											
										
										
											2021-10-27 04:39:28 -04:00
+								        stub_request(:get, canonical_url).to_return(status: 200, body: canonical_content)
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
 								        stub_request(:get, url2).to_return(status: 200, body: content2)
 								        stub_request(:head, canonical_url2)
 								        stub_request(:get, canonical_url2).to_return(status: 200, body: canonical_content)
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								      end
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
+								      it "fetches canonical content" do
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								        response = TopicEmbed.find_remote(url)
 								        expect(response.title).to eq("Canonical")
-												SECURITY: Use canonical url for topic embeddings (#22085)

This prevents duplicate topics from being created when using embed_urls
that only differ on query params.
											
										
										
											2023-06-13 13:08:08 -04:00
+								        expect(response.url).to eq(canonical_url)
 								      end
 								      it "does not create duplicate topics when url differs from canonical_url" do
 								        Jobs.run_immediately!
 								        expect { TopicEmbed.import_remote(canonical_url, { title: title, user: user }) }.to change {
 								          Topic.all.count
 								        }.by(1)
 								        expect { TopicEmbed.import_remote(url, { title: title, user: user }) }.to_not change {
 								          Topic.all.count
 								        }
 								      end
 								      it "does not create duplicate topics when url contains extra params" do
 								        Jobs.run_immediately!
 								        expect {
 								          TopicEmbed.import_remote(canonical_url2, { title: title, user: user })
 								        }.to change { Topic.all.count }.by(1)
 								        expect { TopicEmbed.import_remote(url2, { title: title, user: user }) }.to_not change {
 								          Topic.all.count
 								        }
-												FIX: Follow the canonical URL when importing a remote topic. (#14489)

FinalDestination now supports the `follow_canonical` option, which will perform an initial GET request, parse the canonical link if present, and perform a HEAD request to it.

We use this mode during embeds to avoid treating URLs with different query parameters as different topics.
											
										
										
											2021-10-01 11:48:21 -04:00
+								      end
 								    end
-												FIX: allow emoji class when crawling embedded content, add rspc-html-matchers

											
										
										
											2015-09-24 18:20:59 -04:00
+								  end
-												FIX: Skip absolutizing URLs when source URI is invalid

											
										
										
											2020-02-07 10:54:24 -05:00
+								  describe ".absolutize_urls" do
-												DEV: More robust processing of URLs (#11361)

* DEV: More robust processing of URLs

The previous `UrlHelper.encode_component(CGI.unescapeHTML(UrlHelper.unencode(uri))` method would naively process URLs, which could result in a badly formed response.

`Addressable::URI.normalized_encode(uri)` appears to deal with these edge-cases in a more robust way.

* DEV: onebox should use UrlHelper

* DEV: fix spec

* DEV: Escape output when rendering local links
											
										
										
											2020-12-03 17:16:01 -05:00
+								    it "handles badly formed URIs" do
-												FIX: Handle malformed URLs in `TopicEmbed.absolutize_urls`.

											
										
										
											2022-01-20 21:03:49 -05:00
+								      invalid_url = "http://source.com/#double#anchor"
 								      contents = "hello world new post <a href='/hello'>hello</a>"
-												FIX: Skip absolutizing URLs when source URI is invalid

											
										
										
											2020-02-07 10:54:24 -05:00
+								      raw = TopicEmbed.absolutize_urls(invalid_url, contents)
-												DEV: More robust processing of URLs (#11361)

* DEV: More robust processing of URLs

The previous `UrlHelper.encode_component(CGI.unescapeHTML(UrlHelper.unencode(uri))` method would naively process URLs, which could result in a badly formed response.

`Addressable::URI.normalized_encode(uri)` appears to deal with these edge-cases in a more robust way.

* DEV: onebox should use UrlHelper

* DEV: fix spec

* DEV: Escape output when rendering local links
											
										
										
											2020-12-03 17:16:01 -05:00
+								      expect(raw).to eq("hello world new post <a href=\"http://source.com/hello\">hello</a>")
-												FIX: Skip absolutizing URLs when source URI is invalid

											
										
										
											2020-02-07 10:54:24 -05:00
+								    end
-												FIX: Handle malformed URLs in `TopicEmbed.absolutize_urls`.

											
										
										
											2022-01-20 21:03:49 -05:00
 								    it "handles malformed links" do
 								      url = "https://somesource.com"
-												DEV: Correctly tag heredocs (#16061)

This allows text editors to use correct syntax coloring for the heredoc sections.

Heredoc tag names we use:

languages: SQL, JS, RUBY, LUA, HTML, CSS, SCSS, SH, HBS, XML, YAML/YML, MF, ICS
other: MD, TEXT/TXT, RAW, EMAIL
											
										
										
											2022-02-28 14:50:55 -05:00
+								      contents = <<~HTML
-												DEV: Add `topic_embed_import_create_args` plugin modifier (#26527)

* DEV: Add `topic_embed_import_create_args` plugin modifier

This modifier allows a plugin to change the arguments used when creating
 a new topic for an imported article.

For example: let's say you want to prepend "Imported: " to the title of
every imported topic. You could use this modifier like so:

```ruby
# In your plugin's code
plugin.register_modifier(:topic_embed_import_create_args) do |args|
  args[:title] = "Imported: #{args[:title]}"
  args
end
```

In this example, the modifier is prepending "Imported: " to the `title` in the `create_args` hash. This modified title would then be used when the new topic is created.
											
										
										
											2024-04-05 11:37:53 -04:00
+								        hello world new post <a href="mailto:somemail@somewhere.org>">hello</a>
 								        some image <img src="https:/><invalidimagesrc/">
-												DEV: Correctly tag heredocs (#16061)

This allows text editors to use correct syntax coloring for the heredoc sections.

Heredoc tag names we use:

languages: SQL, JS, RUBY, LUA, HTML, CSS, SCSS, SH, HBS, XML, YAML/YML, MF, ICS
other: MD, TEXT/TXT, RAW, EMAIL
											
										
										
											2022-02-28 14:50:55 -05:00
+								      HTML
-												FIX: Handle malformed URLs in `TopicEmbed.absolutize_urls`.

											
										
										
											2022-01-20 21:03:49 -05:00
 								      raw = TopicEmbed.absolutize_urls(url, contents)
 								      expect(raw).to eq(contents)
 								    end
-												FIX: Skip absolutizing URLs when source URI is invalid

											
										
										
											2020-02-07 10:54:24 -05:00
+								  end
-												FIX: Use default locale for footer of embedded topics (#17760)

The content from the remote site and the footer get cached for 10 minutes, so Discourse should use the default locale instead of the user locale for the footer. Otherwise Discourse might cache the message in a different language.
											
										
										
											2022-08-02 14:49:28 -04:00
+								  describe ".imported_from_html" do
 								    after { I18n.reload! }
 								    it "uses the default site locale for the 'imported_from' footer" do
 								      TranslationOverride.upsert!(
 								        "en",
 								        "embed.imported_from",
 								        "English translation of embed.imported_from with %{link}",
 								      )
 								      TranslationOverride.upsert!(
 								        "de",
 								        "embed.imported_from",
 								        "German translation of embed.imported_from with %{link}",
 								      )
 								      I18n.locale = :en
 								      expected_html = TopicEmbed.imported_from_html("some_url")
 								      I18n.locale = :de
 								      expect(TopicEmbed.imported_from_html("some_url")).to eq(expected_html)
 								    end
-												SECURITY: Encode embed url (#21133)

The embed_url in "This is a companion discussion..." could be used for
XSS.

Co-authored-by: Blake Erickson <o.blakeerickson@gmail.com>
											
										
										
											2023-04-18 03:05:29 -04:00
 								    it "normalize_encodes the url" do
 								      html =
 								        TopicEmbed.imported_from_html(
 								          'http://www.discourse.org/%23<%2Fa><img%20src%3Dx%20onerror%3Dalert("document.domain")%3B>',
 								        )
 								      expected_html =
 								        "\n<hr>\n<small>This is a companion discussion topic for the original entry at <a href='http://www.discourse.org/%23%3C/a%3E%3Cimg%20src=x%20onerror=alert(%22document.domain%22);%3E'>http://www.discourse.org/%23%3C/a%3E%3Cimg%20src=x%20onerror=alert(%22document.domain%22);%3E</a></small>\n"
 								      expect(html).to eq(expected_html)
 								    end
-												FIX: Use default locale for footer of embedded topics (#17760)

The content from the remote site and the footer get cached for 10 minutes, so Discourse should use the default locale instead of the user locale for the footer. Otherwise Discourse might cache the message in a different language.
											
										
										
											2022-08-02 14:49:28 -04:00
+								  end
-												FEATURE: Cache embed contents in the database (#25133)

* FEATURE: Cache embed contents in the database

This will be useful for features that rely on the semantic content of topics, like the many AI features



Co-authored-by: Roman Rizzi <rizziromanalejandro@gmail.com>
											
										
										
											2024-01-05 08:09:31 -05:00
 								  describe ".expanded_for" do
 								    fab!(:user)
 								    let(:title) { "How to turn a fish from good to evil in 30 seconds" }
 								    let(:url) { "http://eviltrout.com/123" }
 								    let(:contents) { "<p>hello world new post :D</p>" }
 								    fab!(:embeddable_host)
 								    fab!(:category)
 								    fab!(:tag)
 								    it "returns embed content" do
 								      stub_request(:get, url).to_return(status: 200, body: contents)
 								      post = TopicEmbed.import(user, url, title, contents)
 								      expect(TopicEmbed.expanded_for(post)).to include(contents)
 								    end
 								    it "updates the embed content cache" do
 								      stub_request(:get, url)
 								        .to_return(status: 200, body: contents)
 								        .then
 								        .to_return(status: 200, body: "contents changed")
 								      post = TopicEmbed.import(user, url, title, contents)
 								      TopicEmbed.expanded_for(post)
 								      expect(post.topic.topic_embed.reload.embed_content_cache).to include("contents changed")
 								    end
 								  end
-												FEATURE: Embeddable Discourse comments, now with simple-rss instead of feedzirra

											
										
										
											2013-12-31 14:37:43 -05:00
+								end