blacklight 7.41.0 → 8.0.0.beta1

data/spec/components/blacklight/response/pagination_component_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Blacklight::Response::PaginationComponent, type: :component do
-  let(:render) do
-    with_request_url '/catalog?q=foo' do
-      render_inline(instance)
-    end
-  end
-
-  let(:instance) { described_class.new(response: response) }
-
-  context 'when there are many results' do
-    let(:response) { instance_double(Blacklight::Solr::Response, total: 10, current_page: 5, limit_value: 10_000, total_pages: 100) }
-
-    context 'with default config' do
-      before { render }
-
-      it "has links to deep pages" do
-        expect(page).not_to have_link '98'
-        expect(page).to have_link '99'
-        expect(page).to have_link '100'
-        expect(page).not_to have_link '101'
-      end
-    end
-
-    context 'when a different configuration that removes deep links is passed as a parameter' do
-      let(:instance) { described_class.new(response: response, left: 5, right: 0, outer_window: nil) }
-
-      before { render }
-
-      it "does not link to deep pages" do
-        expect(page).to have_link '1'
-        expect(page).not_to have_link '100'
-      end
-    end
-
-    context 'when a different configuration that removes deep links is configured in the controller' do
-      before do
-        allow(controller.blacklight_config.index)
-          .to receive(:pagination_options)
-          .and_return(theme: 'blacklight', left: 5, right: 0)
-        render
-      end
-
-      it "does not link to deep pages" do
-        expect(page).to have_link '1'
-        expect(page).not_to have_link '100'
-      end
-    end
-  end
-end

data/spec/components/blacklight/search_context/server_item_pagination_component_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Blacklight::SearchContext::ServerItemPaginationComponent, type: :component do
-  subject(:render) { render_inline(instance) }
-
-  let(:current_document_id) { 9 }
-  let(:current_document) { SolrDocument.new(id: current_document_id) }
-  let(:search_session) { { 'document_id' => current_document_id, 'counter' => 1, 'total' => '3' } }
-  let(:instance) { described_class.new(search_context: search_context, search_session: search_session, current_document: current_document) }
-
-  before do
-    allow(controller).to receive(:search_session).and_return(search_session)
-    allow(controller).to receive(:current_search_session).and_return(double(id: current_document_id))
-    controller.class.helper_method :search_session
-    controller.class.helper_method :current_search_session
-  end
-
-  context 'when there is next and previous' do
-    let(:search_context) { { next: next_doc, prev: prev_doc } }
-    let(:prev_doc) { SolrDocument.new(id: '777') }
-    let(:next_doc) { SolrDocument.new(id: '888') }
-
-    before do
-      # allow(controller).to receive(:controller_tracking_method).and_return('track_catalog_path')
-
-      allow(controller).to receive_messages(controller_name: 'catalog', link_to_previous_document: '', link_to_next_document: '')
-    end
-
-    it "renders content" do
-      expect(render.css('.page-links').to_html).not_to be_blank
-    end
-  end
-end

data/spec/controllers/blacklight/facet_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::Facet do
-  subject do
-    Class.new do
-      include Blacklight::Facet
-      attr_reader :blacklight_config
-
-      def initialize blacklight_config
-        @blacklight_config = blacklight_config
-      end
-    end.new(blacklight_config)
-  end
-
-  let(:blacklight_config) { Blacklight::Configuration.new }
-
-  describe "#facet_configuration_for_field" do
-    it "looks up fields by key" do
-      blacklight_config.add_facet_field 'a'
-      expect(subject.facet_configuration_for_field('a')).to eq blacklight_config.facet_fields['a']
-    end
-
-    it "looks up fields by field name" do
-      blacklight_config.add_facet_field 'a', field: 'b'
-      expect(subject.facet_configuration_for_field('b')).to eq blacklight_config.facet_fields['a']
-    end
-
-    it "supports both strings and symbols" do
-      blacklight_config.add_facet_field 'a', field: :b
-      expect(subject.facet_configuration_for_field('b')).to eq blacklight_config.facet_fields['a']
-    end
-  end
-end

data/spec/controllers/blacklight/search_fields_spec.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::SearchFields do
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
-  class MockConfig
-    include Blacklight::SearchFields
-  end
-
-  before(:all) do
-    @config = Blacklight::Configuration.new do |config|
-      config.default_solr_params = { qt: 'search' }
-
-      config.add_search_field 'all_fields', label: 'All Fields'
-      config.add_search_field 'title', qt: 'title_search'
-      config.add_search_field 'author', qt: 'author_search'
-      config.add_search_field 'subject', qt: 'subject_search'
-      config.add_search_field 'no_display', qt: 'something', include_in_simple_select: false
-    end
-  end
-
-  before do
-    @search_field_obj = MockConfig.new
-    allow(@search_field_obj).to receive(:blacklight_config).and_return(@config)
-  end
-
-  it "returns search field list with calculated :label when needed" do
-    @search_field_obj.search_field_list.each do |hash|
-      expect(hash.label).not_to be_blank
-    end
-  end
-
-  describe "for unspecified :key" do
-    before do
-      @bad_config = MockConfig.new
-    end
-
-    it "raises exception on #search_field_list" do
-      expect do
-        allow(@bad_config).to receive(:blacklight_config).and_return(Blacklight::Configuration.new do |config|
-                                                                       config.add_search_field label: 'All Fields', qt: 'all_fields'
-                                                                       config.add_search_field 'title', qt: 'title_search'
-                                                                     end)
-      end.to raise_error ArgumentError
-    end
-  end
-
-  describe "for duplicate keys" do
-    before do
-      @bad_config = MockConfig.new
-    end
-
-    it "raises on #search_field_list" do
-      expect do
-        allow(@bad_config).to receive(:blacklight_config).and_return(Blacklight::Configuration.new do |config|
-                                                                       config.add_search_field 'my_key', label: 'All Fields'
-                                                                       config.add_search_field 'my_key', label: 'title'
-                                                                     end)
-      end.to raise_error RuntimeError
-    end
-  end
-end

data/spec/features/citation_spec.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'Citation functionality' do
-  before { visit solr_document_path('2007020969') }
-
-  it 'displays the Cite modal with expected header' do
-    click_link 'Cite'
-    expect(find('div.modal-header')).to have_text 'Cite'
-  end
-end

data/spec/features/sitelinks_search_box_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'Sitelinks search box' do
-  it 'is home page' do
-    visit root_path
-    expect(page).to have_selector 'script[type="application/ld+json"]', visible: :hidden
-  end
-
-  it 'on search page' do
-    visit search_catalog_path q: 'book'
-    expect(page).not_to have_selector 'script[type="application/ld+json"]', visible: :hidden
-  end
-end

data/spec/features/sms_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe 'SMS functionality' do
-  before { visit solr_document_path('2007020969') }
-
-  it 'displays SMS modal with form' do
-    click_link 'SMS'
-    expect(find('div.modal-header')).to have_text 'SMS This'
-    fill_in 'Phone Number:', with: '555-555-5555'
-    select 'Verizon', from: 'Carrier'
-  end
-end

data/spec/helpers/blacklight/hash_as_hidden_fields_behavior_spec.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::HashAsHiddenFieldsHelperBehavior do
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
-  let(:params) do
-    { q: "query",
-      search_field: "search_field",
-      per_page: 10,
-      page: 5,
-      extra_arbitrary_key: "arbitrary_value",
-      f: { field1: %w[a b], field2: ["z"] } }
-  end
-  let(:generated) { helper.render_hash_as_hidden_fields(params) }
-
-  it "converts a hash with nested complex data to Rails-style hidden form fields" do
-    allow(Deprecation).to receive(:warn)
-    expect(generated).to have_selector("input[type='hidden'][name='q'][value='query']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='per_page'][value='10']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='page'][value='5']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='extra_arbitrary_key'][value='arbitrary_value']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='f[field2][]'][value='z']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='a']", visible: false)
-    expect(generated).to have_selector("input[type='hidden'][name='f[field1][]'][value='b']", visible: false)
-  end
-end

data/spec/helpers/blacklight/render_constraints_helper_behavior_spec.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
-  let(:config) do
-    Blacklight::Configuration.new do |config|
-      config.add_facet_field 'type'
-      config.add_search_field 'title'
-    end
-  end
-
-  before do
-    # the helper methods below infer paths from the current route
-    controller.request.path_parameters[:controller] = 'catalog'
-    allow(helper).to receive(:search_action_path) do |*args|
-      search_catalog_path *args
-    end
-
-    allow(helper).to receive(:blacklight_config).and_return(config)
-    allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
-  end
-
-  describe '#render_constraints_query' do
-    subject { helper.render_constraints_query(params) }
-
-    let(:my_engine) { double("Engine") }
-    let(:params) { ActionController::Parameters.new(q: 'foobar', f: { type: 'journal' }) }
-
-    it "has a link relative to the current url" do
-      expect(subject).to have_link 'Remove constraint', href: '/catalog?f%5Btype%5D%5B%5D=journal'
-    end
-  end
-
-  describe '#render_constraints_clauses' do
-    subject { helper.render_constraints_clauses(params) }
-
-    let(:my_engine) { double("Engine") }
-    let(:params) { ActionController::Parameters.new(clause: { "0": { field: 'title', query: 'nature' } }, f: { type: 'journal' }) }
-
-    it 'renders the clause constraint' do
-      expect(subject).to have_selector '.constraint-value', text: /Title\s+nature/
-    end
-
-    it "has a link relative to the current url" do
-      expect(subject).to have_link 'Remove constraint Title: nature', href: '/catalog?f%5Btype%5D%5B%5D=journal'
-    end
-  end
-
-  describe '#render_filter_element' do
-    subject { helper.render_filter_element('type', ['journal'], path) }
-
-    before do
-      allow(helper).to receive(:blacklight_config).and_return(config)
-      expect(helper).to receive(:facet_field_label).with('type').and_return("Item Type")
-    end
-
-    let(:params) { ActionController::Parameters.new q: 'biz' }
-    let(:path) { Blacklight::SearchState.new(params, config, controller) }
-
-    it "has a link relative to the current url" do
-      expect(subject).to have_link "Remove constraint Item Type: journal", href: "/catalog?q=biz"
-      expect(subject).to have_selector ".filter-name", text: 'Item Type'
-    end
-
-    context 'with string values' do
-      subject { helper.render_filter_element('type', 'journal', path) }
-
-      it "handles string values gracefully" do
-        expect(subject).to have_link "Remove constraint Item Type: journal", href: "/catalog?q=biz"
-      end
-    end
-
-    context 'with multivalued facets' do
-      subject { helper.render_filter_element('type', [%w[journal book]], path) }
-
-      it "handles such values gracefully" do
-        expect(subject).to have_link "Remove constraint Item Type: journal OR book", href: "/catalog?q=biz"
-      end
-    end
-  end
-
-  describe "#render_constraints_filters" do
-    subject { helper.render_constraints_filters(params) }
-
-    let(:params) { ActionController::Parameters.new f: { 'type' => [''] } }
-
-    it "renders nothing for empty facet limit param" do
-      expect(subject).to be_blank
-    end
-  end
-end

data/spec/helpers/blacklight/search_history_constraints_helper_behavior_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::SearchHistoryConstraintsHelperBehavior do
-  around { |test| Deprecation.silence(described_class) { test.call } }
-
-  before(:all) do
-    @config = Blacklight::Configuration.new do |config|
-      config.add_search_field 'default_search_field', label: 'Default'
-
-      config.add_facet_field 'some_facet', label: 'Some'
-      config.add_facet_field 'other_facet', label: 'Other'
-      config.add_facet_field 'i18n_facet'
-
-      I18n.backend.store_translations(:en, blacklight: { search: { fields: { facet: { i18n_facet: 'English facet label' } } } })
-      I18n.backend.store_translations(:de, blacklight: { search: { fields: { facet: { i18n_facet: 'German facet label' } } } })
-    end
-  end
-
-  before do
-    allow(helper).to receive(:blacklight_config).and_return(@config)
-  end
-
-  describe "render_search_to_s_*" do
-    describe "render_search_to_s_element" do
-      it "renders basic element" do
-        response = helper.render_search_to_s_element("key", "value")
-        expect(response).to have_selector("span.constraint") do |span|
-          expect(span).to have_selector("span.filter-name", text: "key:")
-          expect(span).to have_selector("span.filter-values", text: "value")
-        end
-        expect(response).to be_html_safe
-      end
-
-      it "escapes them that need escaping" do
-        response = helper.render_search_to_s_element("key>", "value>")
-        expect(response).to have_selector("span.constraint") do |span|
-          expect(span).to have_selector("span.filter-name", text: 'key>:')
-          expect(span).to have_selector("span.filter-values", text: 'value>')
-        end
-        expect(response).to be_html_safe
-      end
-
-      xit "does not escape with options set thus" do
-        response = helper.render_search_to_s_element("<key>", "value>", escape_key: false, escape_value: false)
-        expect(response).to have_selector("span.constraint") do |span|
-          expect(span).to have_selector("span.filter-name", text: "key>:")
-          expect(span).to have_selector("span.filter-values", text: "value>")
-        end
-        expect(response).to be_html_safe
-      end
-    end
-
-    describe "render_search_to_s" do
-      before do
-        @params = { q: "history", f: { "some_facet" => %w[value1 value1], "other_facet" => ["other1"] } }
-      end
-
-      it "calls lesser methods" do
-        allow(helper).to receive(:blacklight_config).and_return(@config)
-        allow(helper).to receive(:default_search_field).and_return(Blacklight::Configuration::SearchField.new(key: 'default_search_field', display_label: 'Default'))
-        allow(helper).to receive(:label_for_search_field).with(nil).and_return('')
-        # API hooks expect this to be so
-        response = helper.render_search_to_s(@params)
-
-        expect(response).to include(helper.render_search_to_s_q(@params))
-        expect(response).to include(helper.render_search_to_s_filters(@params))
-        expect(response).to be_html_safe
-      end
-    end
-
-    describe "render_search_to_s_filters" do
-      it "renders a constraint for a selected facet in the config" do
-        response = helper.render_search_to_s_filters(f: { "some_facet" => %w[value1 value2] })
-        expect(response).to eq("<span class=\"constraint\"><span class=\"filter-name\">Some:</span><span class=\"filter-values\"><span class=\"filter-value\">value1</span><span class=\"filter-separator\"> and </span><span class=\"filter-value\">value2</span></span></span>")
-      end
-
-      it "renders a constraint for a selected facet not in the config" do
-        response = helper.render_search_to_s_filters(f: { "undefined_facet" => %w[value1 value2] })
-        expect(response).to eq("<span class=\"constraint\"><span class=\"filter-name\">#{'undefined_facet'.titleize}:</span><span class=\"filter-values\"><span class=\"filter-value\">value1</span><span class=\"filter-separator\"> and </span><span class=\"filter-value\">value2</span></span></span>")
-      end
-
-      context 'with I18n translations for selected facet' do
-        before do
-          @orig_locale = I18n.locale
-        end
-
-        after do
-          I18n.locale = @orig_locale
-        end
-
-        it 'renders the correct I18n label for a selected facet with I18n translations' do
-          { en: 'English facet label', de: 'German facet label' }.each do |locale, label|
-            I18n.locale = locale
-            response = helper.render_search_to_s_filters(f: { 'i18n_facet' => %w[value1 value2] })
-            expect(response).to include(label)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/helpers/blacklight/suggest_helper_behavior_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::SuggestHelperBehavior do
-  before do
-    allow(helper).to receive(:blacklight_config).and_return(blacklight_config)
-    expect(Deprecation).to receive(:warn)
-  end
-
-  describe '#autocomplete_enabled?' do
-    describe 'with autocomplete config' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.autocomplete_enabled = true
-          config.autocomplete_path = 'suggest'
-        end
-      end
-
-      it 'is enabled' do
-        expect(helper.autocomplete_enabled?).to be true
-      end
-    end
-
-    describe 'without disabled config' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.autocomplete_enabled = false
-          config.autocomplete_path = 'suggest'
-        end
-      end
-
-      it 'is disabled' do
-        expect(helper.autocomplete_enabled?).to be false
-      end
-    end
-
-    describe 'without path config' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.autocomplete_enabled = true
-        end
-      end
-
-      it 'is disabled' do
-        expect(helper.autocomplete_enabled?).to be false
-      end
-    end
-  end
-end

data/spec/lib/blacklight/engine_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::Engine do
-  [:bookmarks_http_method, :email_regexp, :facet_missing_param, :sms_mappings].each do |dep_key|
-    describe "config.#{dep_key}" do
-      subject { described_class.config }
-
-      let(:unlikely_value) { 'unlikely value' }
-
-      it 'is deprecated' do
-        allow(Deprecation).to receive(:warn)
-        subject.send(dep_key)
-        expect(Deprecation).to have_received(:warn)
-      end
-
-      it 'delegates to config.blacklight' do
-        allow(subject.blacklight).to receive(dep_key).and_return(unlikely_value)
-        expect(subject.send(dep_key)).to eql(unlikely_value)
-      end
-    end
-
-    describe "config.#{dep_key}=" do
-      subject { described_class.config }
-
-      let(:unlikely_value) { 'unlikely value' }
-
-      it 'is deprecated' do
-        allow(Deprecation).to receive(:warn)
-        allow(subject.blacklight).to receive(:"#{dep_key}=").with(unlikely_value)
-        subject.send(:"#{dep_key}=", unlikely_value)
-        expect(Deprecation).to have_received(:warn)
-      end
-
-      it 'delegates to config.blacklight' do
-        allow(subject.blacklight).to receive(:"#{dep_key}=").with(unlikely_value)
-        subject.send(:"#{dep_key}=", unlikely_value)
-        expect(subject.blacklight).to have_received(:"#{dep_key}=").with(unlikely_value)
-      end
-    end
-  end
-end

data/spec/presenters/blacklight/search_bar_presenter_spec.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-require 'spec_helper'
-
-RSpec.describe Blacklight::SearchBarPresenter do
-  let(:controller) { CatalogController.new }
-  let(:presenter) { described_class.new(controller, blacklight_config) }
-  let(:blacklight_config) { Blacklight::Configuration.new }
-
-  describe '#autocomplete_enabled?' do
-    subject { presenter.autocomplete_enabled? }
-
-    describe 'with autocomplete config' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.autocomplete_enabled = true
-          config.autocomplete_path = 'suggest'
-        end
-      end
-
-      it { is_expected.to be true }
-    end
-
-    describe 'without disabled config' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.autocomplete_enabled = false
-          config.autocomplete_path = 'suggest'
-        end
-      end
-
-      it { is_expected.to be false }
-    end
-
-    describe 'without path config' do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.autocomplete_enabled = true
-        end
-      end
-
-      it { is_expected.to be false }
-    end
-  end
-
-  describe "#autofocus?" do
-    subject { presenter.autofocus? }
-
-    context "on a catalog-like index page without query or facet parameters" do
-      let(:blacklight_config) do
-        Blacklight::Configuration.new.configure do |config|
-          config.enable_search_bar_autofocus = true
-        end
-      end
-
-      before do
-        allow(controller).to receive(:action_name).and_return('index')
-        allow(controller).to receive(:has_search_parameters?).and_return(false)
-      end
-
-      it { is_expected.to be true }
-    end
-
-    context "when disabled in config" do
-      before do
-        allow(controller).to receive(:action_name).and_return('index')
-        allow(controller).to receive(:has_search_parameters?).and_return(false)
-      end
-
-      it { is_expected.to be false }
-    end
-
-    context "when not the catalog controller" do
-      let(:controller) { ApplicationController.new }
-
-      it { is_expected.to be false }
-    end
-
-    context "when on the catalog controller show page" do
-      before do
-        allow(controller).to receive(:action_name).and_return('show')
-      end
-
-      it { is_expected.to be false }
-    end
-
-    context "when search parameters are provided" do
-      before do
-        allow(controller).to receive(:has_search_parameters?).and_return(true)
-      end
-
-      it { is_expected.to be false }
-    end
-  end
-end

data/spec/services/blacklight/field_retriever_spec.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Blacklight::FieldRetriever, api: true do
-  let(:service) { described_class.new(document, blacklight_field_config) }
-
-  let(:blacklight_field_config) { Blacklight::Configuration::Field.new(field: 'author_field', highlight: true) }
-  let(:document) { SolrDocument.new({ 'id' => 'doc1', 'title_field' => 'doc1 title', 'author_field' => 'author_someone' }, 'highlighting' => { 'doc1' => { 'title_tsimext' => ['doc <em>1</em>'] } }) }
-  let(:view_context) { {} }
-
-  context "highlighting" do
-    describe '#fetch' do
-      it "retrieves an author even if it's not highlighted" do
-        expect(service.fetch).to eq(['author_someone'])
-      end
-    end
-  end
-end