Normalize on render_component for view specs

Author: rossta

spec/views/components/clipboard_copy_spec.rb

@@ -1,19 +1,17 @@
 require "rails_helper"
 
 RSpec.describe ClipboardCopy, type: :view do
-  def render(text, &block)
-    Capybara.string(described_class.new(text:).call)
-  end
-
   it "renders the clipboard copy button" do
-    expect(render("Hello")).to have_css("button", text: "Copied!")
+    render_component(text: "Hello")
+
+    expect(rendered).to have_css("button", text: "Copied!")
   end
 
   it "gracefully handles text containing ERB when processed by ERB" do
-    text = "<%= \"color\" %>"
-    rendered = described_class.new(text:).call
+    render_component(text: "<%= \"color\" %>")
+
     processed = ERB.new(rendered).result(binding)
 
-    expect(Capybara.string(processed)).to have_css("[data-value*=color]")
+    expect(processed).to have_css("[data-value*=color]")
   end
 end

spec/views/components/code_block/app_file_run_spec.rb

@@ -1,23 +1,21 @@
 require "rails_helper"
 
 RSpec.describe CodeBlock::AppFileRun, type: :view do
-  def render_page(*, **)
-    Capybara.string(render(*, **))
-  end
-
   before do
     allow(view).to receive(:headers).and_return({"Content-Type" => "text/html"})
   end
 
   it "renders contents of file" do
-    page = render_page(CodeBlock::AppFileRun.new("spec/fixtures/code_block/app_file/example.rb"))
-    expect(page).to have_content(<<~RUBY.strip)
+    render_component("spec/fixtures/code_block/app_file/example.rb")
+
+    expect(rendered).to have_content(<<~RUBY.strip)
       class FixturesCodeBlockAppFileExample
         def add(m, n)
           m + n
         end
       end
     RUBY
-    expect(page).to have_content("spec/fixtures/code_block/app_file/example.rb")
+
+    expect(rendered).to have_content("spec/fixtures/code_block/app_file/example.rb")
   end
 end

spec/views/components/color_schemes/css_spec.rb

@@ -3,10 +3,11 @@
 RSpec.describe ColorSchemes::Css do
   describe "#call" do
     it "renders valid css" do
-      component = described_class.new(color_scheme: FactoryBot.build(:color_scheme))
-
       validator = W3CValidators::CSSValidator.new
-      validator_results = validator.validate_text(component.call)
+
+      render_component(color_scheme: FactoryBot.build(:color_scheme))
+
+      validator_results = validator.validate_text(rendered)
 
       expect(validator_results.is_valid?).to be(true), "Expected feed to be valid, but got: #{validator_results.errors.map(&:to_s).join(", ")}"
     end

spec/views/components/markdown/article_spec.rb

@@ -1,61 +1,60 @@
 require "rails_helper"
 
 RSpec.describe Markdown::Article, type: :view do
-  describe ".call" do
-    before do
-      allow(view).to receive(:headers).and_return({"Content-Type" => "text/html"})
-    end
-
-    def render(content, &block)
-      described_class.new(content).call(view_context: view, &block)
-    end
-
-    it "processes text" do
-      expect(render("Hello")).to match "Hello"
-    end
-
-    it "ignores unfenced erb at start of line" do
-      expect(render("<%= 1 + 1 %>")).to eq("<%= 1 + 1 %>")
-    end
-
-    it "renders article code block" do
-      md = <<~MD
-        ```
-        1 + 1
-        ```
-      MD
-
-      page = Capybara.string(render(md))
-      code = page.find("pre code")
-
-      expect(code).to have_content("1 + 1")
-      expect(page).to have_content("Copied")
-    end
-
-    it "renders arbitrary html" do
-      md = <<~MD
-        <div>Hello</div>
-      MD
-      html = <<~HTML
-        <div>Hello</div>
-      HTML
-      expect(render(md)).to eq(html)
-    end
-
-    it "renders basic code block when content type is atom" do
-      allow(view).to receive(:headers).and_return({"Content-Type" => "application/atom+xml"})
-
-      md = <<~MD
-        ```
-        1 + 1
-        ```
-      MD
-
-      page = Capybara.string(render(md))
-      code = page.find("pre code")
-
-      expect(code).to have_content("1 + 1")
-      expect(page).not_to have_content("Copied!")
-    end
+  before do
+    allow(view).to receive(:headers).and_return({"Content-Type" => "text/html"})
+  end
+
+  it "processes text" do
+    expect(render_component("Hello")).to match "Hello"
+  end
+
+  it "ignores unfenced erb at start of line" do
+    expect(render_component("<%= 1 + 1 %>")).to eq("<%= 1 + 1 %>")
+  end
+
+  it "renders article code block" do
+    md = <<~MD
+      ```
+      1 + 1
+      ```
+    MD
+
+    render_component(md)
+
+    page = Capybara.string(rendered)
+    code = page.find("pre code")
+
+    expect(code).to have_content("1 + 1")
+    expect(page).to have_content("Copied")
+  end
+
+  it "renders arbitrary html" do
+    md = <<~MD
+      <div>Hello</div>
+    MD
+    html = <<~HTML
+      <div>Hello</div>
+    HTML
+
+    expect(render_component(md)).to eq(html)
+  end
+
+  it "renders basic code block when content type is atom" do
+    allow(view).to receive(:headers).and_return({"Content-Type" => "application/atom+xml"})
+
+    md = <<~MD
+      ```
+      1 + 1
+      ```
+    MD
+
+    render_component(md)
+
+    page = Capybara.string(rendered)
+    code = page.find("pre code")
+
+    expect(code).to have_content("1 + 1")
+    expect(page).not_to have_content("Copied!")
   end
 end

spec/views/components/markdown/atom_spec.rb

@@ -1,41 +1,35 @@
 require "rails_helper"
 
 RSpec.describe Markdown::Atom, type: :view do
-  describe ".call" do
-    let(:template) { instance_double(ActionView::Template, type: "") }
+  let(:template) { instance_double(ActionView::Template, type: "") }
 
-    def render(content, &block)
-      described_class.new(content).call(&block)
-    end
-
-    it "processes text" do
-      expect(render("Hello")).to match "Hello"
-    end
+  it "processes text" do
+    expect(render_component("Hello")).to match "Hello"
+  end
 
-    it "ignores unfenced erb at start of line" do
-      expect(render("<%= 1 + 1 %>")).to eq("<%= 1 + 1 %>")
-    end
+  it "ignores unfenced erb at start of line" do
+    expect(render_component("<%= 1 + 1 %>")).to eq("<%= 1 + 1 %>")
+  end
 
-    it "renders basic code block" do
-      md = <<~MD
-        ```
-        1 + 1
-        ```
-      MD
-      html = <<~HTML
-        <pre><code>1 + 1</code></pre>
-      HTML
-      expect(render(md).delete("\n")).to eq(html.delete("\n"))
-    end
+  it "renders basic code block" do
+    md = <<~MD
+      ```
+      1 + 1
+      ```
+    MD
+    html = <<~HTML
+      <pre><code>1 + 1</code></pre>
+    HTML
+    expect(render_component(md).delete("\n")).to eq(html.delete("\n"))
+  end
 
-    it "renders arbitrary html" do
-      md = <<~MD
-        <div>Hello</div>
-      MD
-      html = <<~HTML
-        <div>Hello</div>
-      HTML
-      expect(render(md)).to eq(html)
-    end
+  it "renders arbitrary html" do
+    md = <<~MD
+      <div>Hello</div>
+    MD
+    html = <<~HTML
+      <div>Hello</div>
+    HTML
+    expect(render_component(md)).to eq(html)
   end
 end

spec/views/components/markdown/base_spec.rb

@@ -4,7 +4,7 @@
 
 RSpec.describe Markdown::Base, type: :view do
   it "supports multiple headings" do
-    output = md <<~MD
+    render_component <<~MD
       # 1
       ## 2
       ### 3
@@ -13,106 +13,102 @@
       ###### 6
     MD
 
-    expect(output.strip).to be ==
+    expect(rendered.strip).to be ==
       "<h1>1</h1> <h2>2</h2> <h3>3</h3> <h4>4</h4> <h5>5</h5> <h6>6</h6>"
   end
 
   it "supports ordered lists" do
-    output = md <<~MD
+    render_component <<~MD
       1. One
       2. Two
       3. Three
     MD
 
-    expect(output).to be ==
+    expect(rendered).to be ==
       "<ol><li>One</li> <li>Two</li> <li>Three</li> </ol>"
   end
 
   it "supports unordered lists" do
-    output = md <<~MD
+    render_component <<~MD
       - One
       - Two
       - Three
     MD
 
-    expect(output).to be ==
+    expect(rendered).to be ==
       "<ul><li>One</li> <li>Two</li> <li>Three</li> </ul>"
   end
 
   it "supports inline code" do
-    output = md "Some `code` here"
-    expect(output.strip).to be == "<p>Some <code>code</code> here</p>"
+    render_component "Some `code` here"
+    expect(rendered.strip).to be == "<p>Some <code>code</code> here</p>"
   end
 
   it "supports block code" do
-    output = md <<~MD
+    render_component <<~MD
       ```ruby
       def foo
         bar
       end
       ```
     MD
 
-    expect(output).to be ==
+    expect(rendered).to be ==
       %(<pre><code class="language-ruby">def foo\n  bar\nend\n</code></pre>)
   end
 
   it "supports paragraphs" do
-    output = md "A\n\nB"
-    expect(output.strip).to be == "<p>A</p> <p>B</p>"
+    render_component "A\n\nB"
+    expect(rendered.strip).to be == "<p>A</p> <p>B</p>"
   end
 
   it "supports links" do
-    output = md "[Hello](world 'title')"
-    expect(output.strip).to be == %(<p><a href="world" title="title">Hello</a></p>)
+    render_component "[Hello](world 'title')"
+    expect(rendered.strip).to be == %(<p><a href="world" title="title">Hello</a></p>)
   end
 
   it "supports emphasis" do
-    output = md "*Hello*"
-    expect(output.strip).to be == "<p><em>Hello</em></p>"
+    render_component "*Hello*"
+    expect(rendered.strip).to be == "<p><em>Hello</em></p>"
   end
 
   it "supports strong" do
-    output = md "**Hello**"
-    expect(output.strip).to be == "<p><strong>Hello</strong></p>"
+    render_component "**Hello**"
+    expect(rendered.strip).to be == "<p><strong>Hello</strong></p>"
   end
 
   it "supports blockquotes" do
-    output = md "> Hello"
-    expect(output).to be == "<blockquote><p>Hello</p> </blockquote>"
+    render_component "> Hello"
+    expect(rendered).to be == "<blockquote><p>Hello</p> </blockquote>"
   end
 
   it "supports horizontal rules" do
-    output = md "---"
-    expect(output).to be == "<hr>"
+    render_component "---"
+    expect(rendered).to be == "<hr>"
   end
 
   it "supports images" do
-    output = md "![alt](src 'title')"
-    expect(output.strip).to be == %(<p><img src="src" alt="alt" title="title"></p>)
+    render_component "![alt](src 'title')"
+    expect(rendered.strip).to be == %(<p><img src="src" alt="alt" title="title"></p>)
   end
 
   it "supports softbreaks in content as spaces" do
-    output = md <<~MD
+    render_component <<~MD
       One
       Two
 
       Three
     MD
 
-    expect(output.strip).to be == "<p>One Two</p> <p>Three</p>"
+    expect(rendered.strip).to be == "<p>One Two</p> <p>Three</p>"
   end
 
   xit "supports blockquote [!NOTE]" do
-    output = md <<~MD
+    render_component <<~MD
       > [!NOTE]
       > Hello!
     MD
 
-    expect(output.strip).to match %r{<blockquote><svg .*><p>Hello!</p> </blockquote>}
-  end
-
-  def md(content)
-    Markdown::Base.new(content).call
+    expect(rendered.strip).to match %r{<blockquote><svg .*><p>Hello!</p> </blockquote>}
   end
 end