blacklight 9.0.0.beta1 → 9.0.0

data/spec/presenters/blacklight/constraint_presenter_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe Blacklight::ConstraintPresenter, type: :presenter do
+  subject(:presenter) do
+    described_class.new(facet_item_presenter: facet_item_presenter, field_label: field_label)
+  end
+
+  let(:facet_item_presenter) do
+    instance_double(Blacklight::FacetItemPresenter, label: 'item 1', remove_href: '/catalog')
+  end
+  let(:field_label) { 'field 1' }
+
+  describe '#constraint_label' do
+    subject { presenter.constraint_label }
+
+    it { is_expected.to eq 'item 1' }
+  end
+
+  describe '#field_label' do
+    subject { presenter.field_label }
+
+    it { is_expected.to eq 'field 1' }
+  end
+
+  describe '#remove_href' do
+    subject { presenter.remove_href }
+
+    it { is_expected.to eq '/catalog' }
+  end
+end

data/spec/presenters/blacklight/document_presenter_spec.rb

@@ -29,13 +29,13 @@ RSpec.describe Blacklight::DocumentPresenter do
   end
 
   describe '#field_value' do
-    let(:field_presenter) { instance_double(Blacklight::FieldPresenter, render: 'xyz') }
+    let(:field_presenter) { instance_double(Blacklight::FieldPresenter, render: ['xyz']) }
     let(:field_config) { Blacklight::Configuration::DisplayField.new }
     let(:options) { { a: 1 } }
 
     it 'calls the field presenter' do
       allow(Blacklight::FieldPresenter).to receive(:new).with(request_context, doc, field_config, options).and_return(field_presenter)
-      expect(presenter.field_value(field_config, options)).to eq 'xyz'
+      expect(presenter.field_value(field_config, options)).to eq ['xyz']
     end
 
     it 'can be configured to use an alternate presenter' do
@@ -44,7 +44,7 @@ RSpec.describe Blacklight::DocumentPresenter do
       field_config.presenter = SomePresenter
       allow(SomePresenter).to receive(:new).and_return(instance)
 
-      expect(presenter.field_value(field_config, options)).to eq 'abc'
+      expect(presenter.field_value(field_config, options)).to eq ['abc']
     end
   end
 

data/spec/presenters/blacklight/facet_item_presenter_spec.rb

@@ -56,13 +56,6 @@ RSpec.describe Blacklight::FacetItemPresenter, type: :presenter do
     end
   end
 
-  describe '#constraint_label' do
-    it 'provides the label for the constraint' do
-      allow(facet_config).to receive_messages(query: nil, date: nil, helper_method: nil, url_method: nil)
-      expect(presenter.constraint_label).to eq presenter.label
-    end
-  end
-
   describe '#href' do
     let(:filter_field) { instance_double(Blacklight::SearchState::FilterField, include?: false) }
 

data/spec/presenters/blacklight/field_presenter_spec.rb

@@ -6,6 +6,8 @@ RSpec.describe Blacklight::FieldPresenter, :api do
   let(:request_context) { double('View context', params: { x: '1' }, search_state: search_state, should_render_field?: true, blacklight_config: config) }
   let(:document) do
     SolrDocument.new(id: 1,
+                     'join_true' => %w[a b c],
+                     'separator_options' => %w[d e f],
                      'link_to_facet_true' => 'x',
                      'link_to_facet_named' => 'x',
                      'qwer' => 'document qwer value',
@@ -30,6 +32,8 @@ RSpec.describe Blacklight::FieldPresenter, :api do
     Blacklight::Configuration.new.configure do |config|
       config.add_index_field 'qwer'
       config.add_index_field 'asdf', helper_method: :render_asdf_index_field
+      config.add_index_field 'join_true', join: true
+      config.add_index_field 'separator_options', separator_options: { words_connector: '<br/>', last_word_connector: '<br/>' }
       config.add_index_field 'link_to_facet_true', link_to_facet: true
       config.add_index_field 'link_to_facet_named', link_to_facet: :some_field
       config.add_index_field 'highlight', highlight: true
@@ -40,6 +44,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       config.add_index_field 'alias', field: 'qwer'
       config.add_index_field 'with_default', default: 'value'
       config.add_index_field 'with_steps', steps: [custom_step]
+      config.add_index_field :some_field
       config.add_facet_field :link_to_facet_true
       config.add_facet_field :some_field
     end
@@ -51,25 +56,33 @@ RSpec.describe Blacklight::FieldPresenter, :api do
     context 'when an explicit html value is provided' do
       let(:options) { { value: '<b>val1</b>' } }
 
-      it { is_expected.not_to be_html_safe }
+      it { is_expected.to eq(['<b>val1</b>']) }
+
+      it 'does not mark value as html_safe' do
+        expect(result.first).not_to be_html_safe
+      end
     end
 
     context 'when an explicit array value with unsafe characters is provided' do
       let(:options) { { value: ['<a', 'b'] } }
 
-      it { is_expected.to eq('&lt;a and b').and be_html_safe }
+      it { is_expected.to eq(%w[<a b]) }
+
+      it 'does not mark values as html_safe' do
+        expect(subject.all?(&:html_safe?)).not_to be true
+      end
     end
 
     context 'when an explicit array value is provided' do
       let(:options) { { value: %w[a b c] } }
 
-      it { is_expected.to eq 'a, b, and c' }
+      it { is_expected.to eq %w[a b c] }
     end
 
     context 'when an explicit value is provided' do
       let(:options) { { value: 'asdf' } }
 
-      it { is_expected.to eq 'asdf' }
+      it { is_expected.to eq ['asdf'] }
     end
 
     context 'when field has a helper method' do
@@ -77,7 +90,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
         allow(request_context).to receive(:render_asdf_index_field).and_return('custom asdf value')
       end
 
-      it { is_expected.to eq 'custom asdf value' }
+      it { is_expected.to eq ['custom asdf value'] }
     end
 
     context 'when field has link_to_facet with true' do
@@ -88,7 +101,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'link_to_facet_true' }
 
-      it { is_expected.to eq 'bar' }
+      it { is_expected.to eq ['bar'] }
     end
 
     context 'when field has link_to_facet with a field name' do
@@ -99,7 +112,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'link_to_facet_named' }
 
-      it { is_expected.to eq 'bar' }
+      it { is_expected.to eq ['bar'] }
     end
 
     context 'when no highlight field is available' do
@@ -120,14 +133,14 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'highlight' }
 
-      it { is_expected.to eq '<em>highlight</em>' }
+      it { is_expected.to eq ['<em>highlight</em>'] }
     end
 
     context 'when no options are provided' do
       let(:field_name) { 'qwer' }
 
       it "checks the document field value" do
-        expect(subject).to eq 'document qwer value'
+        expect(subject).to eq ['document qwer value']
       end
     end
 
@@ -138,7 +151,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
 
       let(:field_name) { 'solr_doc_accessor' }
 
-      it { is_expected.to eq '123' }
+      it { is_expected.to eq ['123'] }
     end
 
     context 'when accessor is set to a value' do
@@ -147,7 +160,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       it 'calls the accessor with the field_name as the argument' do
         expect(document).to receive(:solr_doc_accessor).with('explicit_accessor').and_return("123")
 
-        expect(subject).to eq '123'
+        expect(subject).to eq ['123']
       end
     end
 
@@ -157,7 +170,7 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       it 'calls the accessors on the return of the preceeding' do
         allow(document).to receive_message_chain(:solr_doc_accessor, some_method: "123")
 
-        expect(subject).to eq '123'
+        expect(subject).to eq ['123']
       end
     end
 
@@ -165,26 +178,26 @@ RSpec.describe Blacklight::FieldPresenter, :api do
       let(:field_name) { 'explicit_values_with_context' }
 
       it 'calls the accessors on the return of the preceeding' do
-        expect(subject).to eq '1'
+        expect(subject).to eq ['1']
       end
     end
 
     context 'when the field is an alias' do
       let(:field_name) { 'alias' }
 
-      it { is_expected.to eq 'document qwer value' }
+      it { is_expected.to eq ['document qwer value'] }
     end
 
     context 'when the field has a default' do
       let(:field_name) { 'with_default' }
 
-      it { is_expected.to eq 'value' }
+      it { is_expected.to eq ['value'] }
     end
 
     context 'with steps' do
       let(:field_name) { 'with_steps' }
 
-      it { is_expected.to eq 'Static step' }
+      it { is_expected.to eq ['Static step'] }
     end
 
     context 'for a field with the helper_method option' do
@@ -200,12 +213,80 @@ RSpec.describe Blacklight::FieldPresenter, :api do
           args.first
         end
 
-        expect(result).to include :document, :field, :value, :config, :a
-        expect(result[:document]).to eq document
-        expect(result[:field]).to eq 'field_with_helper'
-        expect(result[:value]).to eq ['value']
-        expect(result[:config]).to eq field_config
-        expect(result[:a]).to eq 1
+        expect(result).to contain_exactly({ document: document, field: field_name,
+                                            value: ['value'], config: field_config, a: 1 })
+      end
+    end
+
+    context 'when joining a field' do
+      context 'with join config' do
+        let(:field_name) { :join_true }
+
+        it { is_expected.to eq ['a, b, and c'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+
+      context 'with separator_options' do
+        let(:field_name) { :separator_options }
+
+        it { is_expected.to eq ['d<br/>e<br/>f'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+
+      context 'with join option' do
+        let(:options) { { join: true } }
+        let(:field_name) { 'some_field' }
+
+        it { is_expected.to eq ['1 and 2'] }
+
+        it 'marks the value as html_safe' do
+          expect(result.first).to be_html_safe
+        end
+      end
+    end
+
+    context 'with a single value' do
+      let(:options) { { join: true, value: 1 } }
+
+      it 'is not joined' do
+        expect(result).to eq [1]
+      end
+    end
+
+    context 'with a single html value' do
+      let(:options) { { join: true, value: '<b>value</b>' } }
+
+      it { is_expected.to eq ['<b>value</b>'] }
+
+      it 'does not mark the value as html_safe' do
+        expect(result.first).not_to be_html_safe
+      end
+    end
+
+    context 'when an array containing unsafe characters provided' do
+      let(:options) { { join: true, value: ['<a', 'b'] } }
+
+      it 'html escapes the unsafe characters' do
+        expect(result).to eq ["&lt;a and b"]
+      end
+
+      it 'marks the value as html_safe' do
+        expect(result.first).to be_html_safe
+      end
+    end
+
+    context 'when outside the html context' do
+      let(:field_name) { :join_true }
+      let(:options) { { format: 'json' } }
+
+      it 'does not join the values' do
+        expect(result).to eq %w[a b c]
       end
     end
   end

data/spec/presenters/blacklight/json_presenter_spec.rb

@@ -56,5 +56,22 @@ RSpec.describe Blacklight::JsonPresenter, :api do
         expect(search_facets.map(&:name)).to eq ['format_si']
       end
     end
+
+    context 'when facets are in multiple groups' do
+      before do
+        config.add_facet_field 'author_tsim', label: 'author', group: 'other-group'
+      end
+
+      let(:aggregations) do
+        {
+          'format_si' => Blacklight::Solr::Response::Facets::FacetField.new("format_si", [{ label: "Book", value: 'Book', hits: 20 }]),
+          'author_tsim' => Blacklight::Solr::Response::Facets::FacetField.new("author_tsim", [{ label: "Julie", value: 'Julie', hits: 1 }])
+        }
+      end
+
+      it 'filters out the facets that are not defined' do
+        expect(search_facets.map(&:name)).to eq %w[format_si author_tsim]
+      end
+    end
   end
 end

data/spec/presenters/blacklight/rendering/pipeline_spec.rb

@@ -12,20 +12,15 @@ RSpec.describe Blacklight::Rendering::Pipeline do
     let(:values) { %w[a b] }
     let(:field_config) { Blacklight::Configuration::NullField.new }
 
-    it { is_expected.to eq "a and b" }
-
-    context "when separator_options are in the config" do
-      let(:values) { %w[c d] }
-      let(:field_config) { Blacklight::Configuration::NullField.new(itemprop: nil, separator_options: { two_words_connector: '; ' }) }
-
-      it { is_expected.to eq "c; d" }
-    end
+    it { is_expected.to eq %w[a b] }
 
     context "when itemprop is in the config" do
       let(:values) { ['a'] }
       let(:field_config) { Blacklight::Configuration::NullField.new(itemprop: 'some-prop', separator_options: nil) }
 
-      it { is_expected.to have_css("span[@itemprop='some-prop']", text: "a") }
+      it 'renders the expected markup' do
+        expect(rendered.first).to have_css("span[@itemprop='some-prop']", text: "a")
+      end
     end
 
     it 'sets the operations on the instance as equal to the class variable' do
@@ -37,13 +32,134 @@ RSpec.describe Blacklight::Rendering::Pipeline do
     end
 
     context 'outside of an HTML context' do
-      let(:options) { { format: 'text' } }
+      context 'when options determines format' do
+        let(:options) { { format: 'text' } }
+
+        let(:values) { ['"blah"', "<notatag>"] }
+        let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+
+        it 'does not HTML escape values or inject HTML tags' do
+          expect(rendered).to eq ['"blah"', "<notatag>"]
+        end
+      end
+
+      context 'when context determines format' do
+        let(:values) { ['"blah"', "<notatag>"] }
+        let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+        let(:controller) { CatalogController.new }
+        let(:search_state) { Blacklight::SearchState.new({ format: 'text' }, controller.blacklight_config, controller) }
+
+        before { allow(context).to receive(:search_state).and_return(search_state) }
+
+        it 'does not HTML escape values or inject HTML tags' do
+          expect(rendered).to eq ['"blah"', '<notatag>']
+        end
+      end
+    end
+
+    context 'when link_to_facet is in the config' do
+      let(:values) { %w[book manuscript] }
+      let(:field_config) { Blacklight::Configuration::Field.new(field: 'format', key: 'format', link_to_facet: true) }
+      let(:controller) { CatalogController.new }
+      let(:search_state) { Blacklight::SearchState.new({}, controller.blacklight_config, controller) }
+
+      before do
+        allow(context).to receive(:search_state).and_return(search_state)
+        allow(context).to receive(:search_action_path) { |f| "/catalog?f[format][]=#{f['f']['format'].first}" }
+        allow(context).to receive(:link_to) { |value, link|  ActiveSupport::SafeBuffer.new("<a href=#{link}>#{value}</a>") }
+      end
+
+      it 'renders html' do
+        expect(rendered).to eq ["<a href=/catalog?f[format][]=book>book</a>", "<a href=/catalog?f[format][]=manuscript>manuscript</a>"]
+      end
+
+      context 'outside html context' do
+        let(:values) { %w[book manuscript] }
+        let(:field_config) { Blacklight::Configuration::Field.new(field: 'format', link_to_facet: true) }
+        let(:search_state) { Blacklight::SearchState.new({ format: 'json' }, CatalogController.blacklight_config, CatalogController.new) }
+
+        it 'does not render html' do
+          expect(rendered).to eq %w[book manuscript]
+        end
+      end
+    end
+
+    context 'when joining values' do
+      context 'with join in the config' do
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'joins the values' do
+          expect(rendered).to eq ['a and b']
+        end
+      end
+
+      context 'with join is in the options' do
+        let(:options) { { join: true } }
+        let(:field_config) { Blacklight::Configuration::NullField.new }
+
+        it 'joins the values' do
+          expect(rendered).to eq ['a and b']
+        end
+      end
+
+      context 'with separator_options in the config' do
+        let(:values) { %w[c d] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(separator_options: { two_words_connector: '; ' }) }
+
+        it { is_expected.to eq ["c; d"] }
+      end
+
+      context 'with a single value' do
+        let(:values) { [1] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'does not run the join step' do
+          expect(rendered).to eq [1]
+        end
+      end
+
+      context 'with a single html value' do
+        let(:values) { ['<b>value</b>'] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'does not escape the html' do
+          expect(rendered).to eq ['<b>value</b>']
+        end
+
+        it 'does not mark the value as html_safe' do
+          expect(rendered.first).not_to be_html_safe
+        end
+      end
+
+      context 'with an array of values containing unsafe characters' do
+        let(:values) { ['<a', 'b'] }
+        let(:field_config) { Blacklight::Configuration::NullField.new(join: true) }
+
+        it 'escapes the unsafe characters' do
+          expect(rendered).to eq ["&lt;a and b"]
+        end
+
+        it 'marks the joined value as html_safe' do
+          expect(rendered.first).to be_html_safe
+        end
+      end
+
+      context 'outside the html context' do
+        let(:values) { %w[a b <c] }
+        let(:field_config) { Blacklight::Configuration::Field.new(join: true) }
+        let(:options) { { format: 'json' } }
+
+        it 'does not run the join step' do
+          expect(rendered).to eq %w[a b <c]
+        end
 
-      let(:values) { ['"blah"', "<notatag>"] }
-      let(:field_config) { Blacklight::Configuration::NullField.new itemprop: 'some-prop' }
+        it 'does not escape unsafe html characters' do
+          expect(rendered.last).to eq '<c'
+        end
 
-      it 'does not HTML escape values or inject HTML tags' do
-        expect(rendered).to eq '"blah" and <notatag>'
+        it 'does not mark the values as html_safe' do
+          expect(rendered.none?(&:html_safe?)).to be true
+        end
       end
     end
   end

data/spec/services/blacklight/search_service_spec.rb

@@ -12,22 +12,19 @@ RSpec.describe Blacklight::SearchService, :api do
   subject { service }
 
   let(:context) { { whatever: :value } }
-  let(:service) { described_class.new(config: blacklight_config, user_params: user_params, **context) }
+  let(:search_state) { Blacklight::SearchState.new(user_params, blacklight_config) }
+  let(:service) { described_class.new(config: blacklight_config, search_state: search_state, **context) }
   let(:repository) { Blacklight::Solr::Repository.new(blacklight_config) }
   let(:user_params) { {} }
 
-  let(:blacklight_config) { Blacklight::Configuration.new }
-  let(:copy_of_catalog_config) { CatalogController.blacklight_config.deep_copy }
-  let(:blacklight_solr) { RSolr.connect(Blacklight.connection_config.except(:adapter)) }
+  let(:blacklight_config) { CatalogController.blacklight_config.deep_copy }
 
   let(:all_docs_query) { '' }
   let(:no_docs_query) { 'zzzzzzzzzzzz' }
-  #  f[format][]=Book&f[language_facet][]=English
   let(:single_facet) { { format: 'Book' } }
 
   before do
     allow(service).to receive(:repository).and_return(repository)
-    service.repository.connection = blacklight_solr
   end
 
   describe '#search_builder_class' do
@@ -39,8 +36,7 @@ RSpec.describe Blacklight::SearchService, :api do
 
     context 'when the search_builder_class is passed in' do
       let(:klass) { double("Search builder") }
-
-      let(:service) { described_class.new(config: blacklight_config, user_params: user_params, search_builder_class: klass) }
+      let(:context) { { search_builder_class: klass } }
 
       it 'uses the passed value' do
         expect(subject).to eq klass
@@ -50,16 +46,15 @@ RSpec.describe Blacklight::SearchService, :api do
 
   # SPECS FOR SEARCH RESULTS FOR QUERY
   describe 'Search Results', :integration do
-    let(:blacklight_config) { copy_of_catalog_config }
-
     describe 'for a sample query returning results' do
       let(:user_params) { { q: all_docs_query } }
+      let(:blacklight_solr) { service.repository.connection }
 
       it "uses the configured request handler" do
         allow(blacklight_config).to receive(:default_solr_params).and_return(qt: 'custom_request_handler')
         allow(blacklight_solr).to receive(:send_and_receive) do |path, params|
           expect(path).to eq 'select'
-          expect(params[:params]['facet.field']).to eq ["format", "{!ex=pub_date_ssim_single}pub_date_ssim", "subject_ssim", "language_ssim", "lc_1letter_ssim", "subject_geo_ssim", "subject_era_ssim"]
+          expect(params[:params]['facet.field']).to contain_exactly "format", "{!ex=pub_date_ssim_single}pub_date_ssim", "subject_ssim", "language_ssim", "lc_1letter_ssim", "subject_geo_ssim", "subject_era_ssim"
           expect(params[:params]["facet.query"]).to eq ["pub_date_ssim:[#{5.years.ago.year} TO *]", "pub_date_ssim:[#{10.years.ago.year} TO *]", "pub_date_ssim:[#{25.years.ago.year} TO *]"]
           expect(params[:params]).to include('rows' => 10, 'qt' => "custom_request_handler", 'q' => "", "f.subject_ssim.facet.limit" => 21, 'sort' => "score desc, pub_date_si desc, title_si asc")
         end.and_return('response' => { 'docs' => [] })
@@ -68,7 +63,6 @@ RSpec.describe Blacklight::SearchService, :api do
     end
 
     describe "for a query returning a grouped response" do
-      let(:blacklight_config) { copy_of_catalog_config }
       let(:user_params) { { q: all_docs_query } }
 
       before do
@@ -82,7 +76,6 @@ RSpec.describe Blacklight::SearchService, :api do
     end
 
     describe "for a query returning multiple groups", :integration do
-      let(:blacklight_config) { copy_of_catalog_config }
       let(:user_params) { { q: all_docs_query } }
 
       before do
@@ -140,7 +133,6 @@ RSpec.describe Blacklight::SearchService, :api do
 
   # SPECS FOR SEARCH RESULTS FOR FACETS
   describe 'Facets in Search Results for All Docs Query', :integration do
-    let(:blacklight_config) { copy_of_catalog_config }
     let(:user_params) { { q: all_docs_query } }
 
     before do
@@ -185,7 +177,6 @@ RSpec.describe Blacklight::SearchService, :api do
 
   # SPECS FOR SEARCH RESULTS FOR PAGING
   describe 'Paging', :integration do
-    let(:blacklight_config) { copy_of_catalog_config }
     let(:user_params) { { q: all_docs_query } }
 
     it 'starts with first results by default' do
@@ -379,18 +370,6 @@ RSpec.describe Blacklight::SearchService, :api do
   # TODO: maybe eventually check other types of solr requests
   #  more like this
   #  nearby on shelf
-  it "raises a Blacklight exception if RSolr can't connect to the Solr instance" do
-    allow(blacklight_solr).to receive(:send_and_receive).and_raise(Errno::ECONNREFUSED)
-    expect { service.repository.search }.to raise_exception(/Unable to connect to Solr instance/)
-  end
-
-  it "raises a Blacklight exception if RSolr raises a timeout error connecting to Solr instance" do
-    rsolr_timeout = RSolr::Error::Timeout.new(nil, nil)
-    allow(rsolr_timeout).to receive(:to_s).and_return("mocked RSolr timeout")
-
-    allow(blacklight_solr).to receive(:send_and_receive).and_raise(rsolr_timeout)
-    expect { service.repository.search }.to raise_exception(Blacklight::Exceptions::RepositoryTimeout, /Timeout connecting to Solr instance/)
-  end
 
   describe "#previous_and_next_documents_for_search" do
     let(:user_params) { { q: '', per_page: 100 } }

data/spec/spec_helper.rb

@@ -21,7 +21,6 @@ require 'selenium-webdriver'
 require 'equivalent-xml'
 require 'axe-rspec'
 
-require 'rsolr'
 require 'blacklight'
 
 Capybara.javascript_driver = :headless_chrome

data/spec/support/presenter_test_helpers.rb

@@ -2,7 +2,7 @@
 
 module PresenterTestHelpers
   def controller
-    @controller ||= ViewComponent::Base.test_controller.constantize.new.tap { |c| c.request = request }.extend(Rails.application.routes.url_helpers)
+    @controller ||= ApplicationController.new.tap { |c| c.request = request }.extend(Rails.application.routes.url_helpers)
   end
 
   def request

data/spec/support/view_component_test_helpers.rb

@@ -1,24 +1,6 @@
 # frozen_string_literal: true
 
 module ViewComponentTestHelpers
-  # Work around for https://github.com/teamcapybara/capybara/issues/2466
-  def render_inline_to_capybara_node(component)
-    Capybara::Node::Simple.new(render_inline(component).to_s)
-  end
-
-  # Work-around for https://github.com/ViewComponent/view_component/pull/1661
-  # which made the component test's controller method (more) private. This makes
-  # it available so we can set up controller-level state for our tests.
-  def controller
-    # ViewComponent 2.x
-    return super if defined?(super)
-
-    # ViewComponent 3.x
-    return vc_test_controller if defined?(vc_test_controller)
-
-    ApplicationController.new.extend(Rails.application.routes.url_helpers)
-  end
-
   # Nokogiri 1.15.0 upgrades the vendored libxml2 from v2.10.4 to v2.11.3
   # libxml2 v2.11.0 introduces a change to parsing HTML href attributes
   # in nokogiri < 1.15, brackets in href attributes are escaped: