Merge pull request #3606 from projectblacklight/modernize-view-component-testing

Modernized view component testing

Author: jcoyne

spec/components/blacklight/advanced_search_form_component_spec.rb

@@ -3,49 +3,42 @@
 require 'spec_helper'
 
 RSpec.describe Blacklight::AdvancedSearchFormComponent, type: :component do
-  subject(:render) do
-    component.render_in(view_context)
-  end
-
   let(:component) { described_class.new(url: '/whatever', response: response, params: params) }
   let(:response) { Blacklight::Solr::Response.new({ facet_counts: { facet_fields: { format: { 'Book' => 10, 'CD' => 5 } } } }.with_indifferent_access, {}) }
   let(:params) { {} }
 
-  let(:rendered) do
-    Capybara::Node::Simple.new(render)
-  end
-
-  let(:view_context) { controller.view_context }
+  let(:view_context) { vc_test_controller.view_context }
 
   before do
     allow(view_context).to receive(:facet_limit_for).and_return(nil)
+    render_inline component
   end
 
   context 'with additional parameters' do
     let(:params) { { some: :parameter, an_array: [1, 2] } }
 
     it 'adds additional parameters as hidden fields' do
-      expect(rendered).to have_field 'some', with: 'parameter', type: :hidden
-      expect(rendered).to have_field 'an_array[]', with: '1', type: :hidden
-      expect(rendered).to have_field 'an_array[]', with: '2', type: :hidden
+      expect(page).to have_field 'some', with: 'parameter', type: :hidden
+      expect(page).to have_field 'an_array[]', with: '1', type: :hidden
+      expect(page).to have_field 'an_array[]', with: '2', type: :hidden
     end
   end
 
   it 'has text fields for each search field' do
-    expect(rendered).to have_css '.advanced-search-field', count: 4
-    expect(rendered).to have_field 'clause_0_field', with: 'all_fields', type: :hidden
-    expect(rendered).to have_field 'clause_1_field', with: 'title', type: :hidden
-    expect(rendered).to have_field 'clause_2_field', with: 'author', type: :hidden
-    expect(rendered).to have_field 'clause_3_field', with: 'subject', type: :hidden
+    expect(page).to have_css '.advanced-search-field', count: 4
+    expect(page).to have_field 'clause_0_field', with: 'all_fields', type: :hidden
+    expect(page).to have_field 'clause_1_field', with: 'title', type: :hidden
+    expect(page).to have_field 'clause_2_field', with: 'author', type: :hidden
+    expect(page).to have_field 'clause_3_field', with: 'subject', type: :hidden
   end
 
   it 'has filters' do
-    expect(rendered).to have_css '.blacklight-format'
-    expect(rendered).to have_field 'f_inclusive[format][]', with: 'Book'
-    expect(rendered).to have_field 'f_inclusive[format][]', with: 'CD'
+    expect(page).to have_css '.blacklight-format'
+    expect(page).to have_field 'f_inclusive[format][]', with: 'Book'
+    expect(page).to have_field 'f_inclusive[format][]', with: 'CD'
   end
 
   it 'has a sort field' do
-    expect(rendered).to have_select 'sort', options: %w[relevance year author title]
+    expect(page).to have_select 'sort', options: %w[relevance year author title]
   end
 end

spec/components/blacklight/constraint_layout_component_spec.rb

@@ -3,8 +3,8 @@
 require 'spec_helper'
 
 RSpec.describe Blacklight::ConstraintLayoutComponent, type: :component do
-  subject(:rendered) do
-    render_inline_to_capybara_node(described_class.new(**params))
+  before do
+    render_inline described_class.new(**params)
   end
 
   describe "for simple display" do
@@ -13,7 +13,7 @@
     end
 
     it "renders label and value" do
-      expect(rendered).to have_css("span.applied-filter.constraint") do |s|
+      expect(page).to have_css("span.applied-filter.constraint") do |s|
         expect(s).to have_css("span.constraint-value")
         expect(s).to have_no_css("a.constraint-value")
         expect(s).to have_css "span.filter-name", text: "my label"
@@ -28,13 +28,13 @@
     end
 
     it "includes remove link" do
-      expect(rendered).to have_css("span.applied-filter") do |s|
+      expect(page).to have_css("span.applied-filter") do |s|
         expect(s).to have_css(".remove[href='http://remove']")
       end
     end
 
     it "has an accessible remove label" do
-      expect(rendered).to have_css(".remove") do |s|
+      expect(page).to have_css(".remove") do |s|
         expect(s).to have_css('.visually-hidden', text: 'Remove constraint my label: my value')
       end
     end
@@ -46,7 +46,7 @@
     end
 
     it "includes them" do
-      expect(rendered).to have_css("span.applied-filter.constraint.class1.class2")
+      expect(page).to have_css("span.applied-filter.constraint.class1.class2")
     end
   end
 
@@ -56,8 +56,8 @@
     end
 
     it "does not escape key and value" do
-      expect(rendered).to have_css("span.applied-filter.constraint span.filter-name span.custom_label")
-      expect(rendered).to have_css("span.applied-filter.constraint span.filter-value span.custom_value")
+      expect(page).to have_css("span.applied-filter.constraint span.filter-name span.custom_label")
+      expect(page).to have_css("span.applied-filter.constraint span.filter-value span.custom_value")
     end
   end
 end

spec/components/blacklight/constraints_component_spec.rb

@@ -5,7 +5,7 @@
 RSpec.describe Blacklight::ConstraintsComponent, type: :component do
   subject(:component) { described_class.new(**params) }
 
-  let(:rendered) { render_inline_to_capybara_node(component) }
+  before { render_inline(component) }
 
   let(:params) do
     { search_state: search_state }
@@ -32,35 +32,35 @@
     let(:query_params) { { q: 'some query' } }
 
     it 'renders a start-over link' do
-      expect(rendered).to have_link 'Start Over', href: '/catalog'
+      expect(page).to have_link 'Start Over', href: '/catalog'
     end
 
     it 'has a header' do
-      expect(rendered).to have_css('h2', text: 'Search Constraints')
+      expect(page).to have_css('h2', text: 'Search Constraints')
     end
 
     it 'wraps the output in a div' do
-      expect(rendered).to have_css('div#appliedParams')
+      expect(page).to have_css('div#appliedParams')
     end
 
     it 'renders the query' do
-      expect(rendered).to have_css('.applied-filter.constraint', text: 'some query')
+      expect(page).to have_css('.applied-filter.constraint', text: 'some query')
     end
   end
 
   context 'with a facet' do
     let(:query_params) { { f: { some_facet: ['some value'] } } }
 
     it 'renders the query' do
-      expect(rendered).to have_css('.constraint-value > .filter-name', text: 'Some Facet').and(have_css('.constraint-value > .filter-value', text: 'some value'))
+      expect(page).to have_css('.constraint-value > .filter-name', text: 'Some Facet').and(have_css('.constraint-value > .filter-value', text: 'some value'))
     end
 
     context 'that is not configured' do
       let(:query_params) { { f: { some_facet: ['some value'], missing: ['another value'] } } }
 
       it 'renders only the configured constraints' do
-        expect(rendered).to have_css('.constraint-value > .filter-name', text: 'Some Facet').and(have_css('.constraint-value > .filter-value', text: 'some value'))
-        expect(rendered).to have_no_css('.constraint-value > .filter-name', text: 'Missing')
+        expect(page).to have_css('.constraint-value > .filter-name', text: 'Some Facet').and(have_css('.constraint-value > .filter-value', text: 'some value'))
+        expect(page).to have_no_css('.constraint-value > .filter-name', text: 'Missing')
       end
     end
   end
@@ -71,15 +71,15 @@
     let(:query_params) { { q: 'some query', f: { some_facet: ['some value'] } } }
 
     it 'wraps the output in a span' do
-      expect(rendered).to have_css('span .constraint')
+      expect(page).to have_css('span .constraint')
     end
 
     it 'renders the search state as lightly-decorated text' do
-      expect(rendered).to have_css('.constraint > .filter-values', text: 'some query').and(have_css('.constraint', text: 'Some Facet:some value'))
+      expect(page).to have_css('.constraint > .filter-values', text: 'some query').and(have_css('.constraint', text: 'Some Facet:some value'))
     end
 
     it 'omits the headers' do
-      expect(rendered).to have_no_css('h2', text: 'Search Constraints')
+      expect(page).to have_no_css('h2', text: 'Search Constraints')
     end
   end
 end

spec/components/blacklight/document/action_component_spec.rb

@@ -6,35 +6,43 @@
   subject(:component) { described_class.new(document: document, action: action, **attr) }
 
   let(:action) { Blacklight::Configuration::ToolConfig.new(key: 'some_tool', name: 'some_tool', component: true) }
-  let(:attr) { {} }
-  let(:view_context) { controller.view_context }
-  let(:render) do
-    component.render_in(view_context)
-  end
-
-  let(:rendered) do
-    Capybara::Node::Simple.new(render)
-  end
-
   let(:document) do
     SolrDocument.new(
       id: 'x'
     )
   end
+  let(:attr) { {} }
+  let(:view_context) { vc_test_controller.view_context }
+
+  before do
+    # Every call to view_context returns a different object. This ensures it stays stable.
+    allow(vc_test_controller).to receive_messages(view_context: view_context)
+  end
 
-  it 'renders an action link' do
-    allow(view_context).to receive(:some_tool_solr_document_path).with(document, { only_path: true }).and_return('/asdf')
+  context 'with a configured path' do
+    before do
+      allow(view_context).to receive(:some_tool_solr_document_path).with(document, { only_path: true }).and_return('/asdf')
 
-    expect(rendered).to have_link 'Some tool', href: '/asdf'
+      render_inline component
+    end
+
+    it 'renders an action link' do
+      expect(page).to have_link 'Some tool', href: '/asdf'
+    end
   end
 
   context 'with a partial configured' do
     let(:action) { Blacklight::Configuration::ToolConfig.new(name: '', partial: '/some/tool') }
 
-    it 'render the partial' do
+    before do
+      allow(view_context).to receive(:render).and_call_original
       allow(view_context).to receive(:render).with(hash_including(partial: '/some/tool'), {}).and_return('tool')
 
-      expect(rendered).to have_content 'tool'
+      render_inline component
+    end
+
+    it 'render the partial' do
+      expect(page).to have_content 'tool'
     end
   end
 end

spec/components/blacklight/document/group_component_spec.rb

@@ -6,40 +6,35 @@
   subject(:component) { described_class.new(group: group, **attr) }
 
   let(:attr) { {} }
-  let(:view_context) { controller.view_context }
-  let(:render) do
-    component.render_in(view_context)
-  end
-
-  let(:rendered) do
-    Capybara::Node::Simple.new(render)
-  end
-
-  let(:docs) { 10.times.map { double } }
+  let(:view_context) { vc_test_controller.view_context }
+  let(:docs) { 10.times.map { SolrDocument.new } }
 
   let(:group) do
     instance_double(Blacklight::Solr::Response::Group, key: 'group1', field: 'group_field', total: 15, docs: docs)
   end
 
   before do
+    # Every call to view_context returns a different object. This ensures it stays stable.
+    allow(vc_test_controller).to receive_messages(view_context: view_context)
     allow(view_context).to receive(:render_document_index).with(docs).and_return('results')
+    render_inline component
   end
 
   it 'renders the group with a header' do
-    expect(rendered).to have_css 'div.group'
-    expect(rendered).to have_css 'h2', text: 'group1'
-    expect(rendered).to have_no_link 'more'
+    expect(page).to have_css 'div.group'
+    expect(page).to have_css 'h2', text: 'group1'
+    expect(page).to have_no_link 'more'
   end
 
   it 'renders the group documents' do
-    expect(rendered).to have_content 'results'
+    expect(page).to have_content 'results'
   end
 
   context 'with a limit applied' do
     let(:attr) { { group_limit: 5 } }
 
     it 'renders a control to see more results' do
-      expect(rendered).to have_link 'more'
+      expect(page).to have_link 'more'
     end
   end
 end