blacklight 6.14.0 → 7.0.0

data/spec/views/catalog/{_thumbnail_default.erb_spec.rb → _thumbnail.html.erb_spec.rb}

@@ -1,13 +1,12 @@
 # frozen_string_literal: true
 
-describe "catalog/_thumbnail_default" do
-
+RSpec.describe "catalog/_thumbnail" do
   let :document_without_thumbnail_field do
-    SolrDocument.new :id => 'xyz', :format => 'a'
+    SolrDocument.new id: 'xyz', format: 'a'
   end
 
   let :document_with_thumbnail_field do
-    SolrDocument.new :id => 'xyz', :format => 'a', :thumbnail_url => 'http://localhost/logo.png'
+    SolrDocument.new id: 'xyz', format: 'a', thumbnail_url: 'http://localhost/logo.png'
   end
 
   let :blacklight_config do
@@ -21,18 +20,17 @@ describe "catalog/_thumbnail_default" do
     assign :response, instance_double(Blacklight::Solr::Response, start: 0)
     allow(view).to receive(:render_grouped_response?).and_return false
     allow(view).to receive(:blacklight_config).and_return(blacklight_config)
-    allow(view).to receive(:current_search_session).and_return nil
-    allow(view).to receive(:search_session).and_return({})
+    allow(view).to receive(:session_tracking_params).and_return({})
   end
 
   it "renders the thumbnail if the document has one" do
-    render :partial => "catalog/thumbnail_default", :locals => {:document => document_with_thumbnail_field, :document_counter => 1}
+    render partial: "catalog/thumbnail", locals: { document: document_with_thumbnail_field, document_counter: 1 }
     expect(rendered).to match /document-thumbnail/
-    expect(rendered).to match /src="http:\/\/localhost\/logo.png"/
+    expect(rendered).to match %r{src="http://localhost/logo.png"}
   end
 
   it "does not render a thumbnail if the document does not have one" do
-    render :partial => "catalog/thumbnail_default", :locals => {:document => document_without_thumbnail_field, :document_counter => 1}
+    render partial: "catalog/thumbnail", locals: { document: document_without_thumbnail_field, document_counter: 1 }
     expect(rendered).to eq ""
   end
 end

data/spec/views/catalog/_view_type_group.html.erb_spec.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
-describe "catalog/_view_type_group" do
+RSpec.describe "catalog/_view_type_group" do
   let(:blacklight_config) { Blacklight::Configuration.new }
   let(:response) { instance_double(Blacklight::Solr::Response, empty?: false) }
+  let(:icon_instance) { instance_double(Blacklight::Icon) }
 
   before do
-    allow(view).to receive(:view_label) do |view|
-      view.to_s
-    end
+    allow(view).to receive(:view_label), &:to_s
+    allow(Blacklight::Icon).to receive(:new).and_return icon_instance
+    allow(icon_instance).to receive(:svg).and_return '<svg></svg>'
+    allow(icon_instance).to receive(:options).and_return({})
     allow(view).to receive_messages(how_sort_and_per_page?: true, blacklight_config: blacklight_config)
     controller.request.path_parameters[:action] = 'index'
     assign(:response, response)
@@ -28,9 +30,9 @@ describe "catalog/_view_type_group" do
     end
     render partial: 'catalog/view_type_group'
     expect(rendered).to have_selector('.btn-group.view-type-group')
-    expect(rendered).to have_selector('.view-type-a', :text => 'a')
-    expect(rendered).to have_selector('.view-type-b', :text => 'b')
-    expect(rendered).to have_selector('.view-type-c', :text => 'c')
+    expect(rendered).to have_selector('.view-type-a', text: 'a')
+    expect(rendered).to have_selector('.view-type-b', text: 'b')
+    expect(rendered).to have_selector('.view-type-c', text: 'c')
   end
 
   it "sets the current view to 'active'" do
@@ -40,8 +42,8 @@ describe "catalog/_view_type_group" do
       config.view.b
     end
     render partial: 'catalog/view_type_group'
-    expect(rendered).to have_selector('.active', :text => 'a')
-    expect(rendered).to_not have_selector('.active', :text => 'b')
-    expect(rendered).to have_selector('.btn', :text => 'b')
+    expect(rendered).to have_selector('.active', text: 'a')
+    expect(rendered).not_to have_selector('.active', text: 'b')
+    expect(rendered).to have_selector('.btn', text: 'b')
   end
 end

data/spec/views/catalog/email_success.html.erb_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.describe "catalog/email_success.html.erb" do
+  it "includes the data-blacklight-modal properties" do
+    render
+    expect(rendered).to have_selector "div[data-blacklight-modal=container]"
+  end
+end

data/spec/views/catalog/facet.html.erb_spec.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-describe 'catalog/facet.html.erb' do
+RSpec.describe 'catalog/facet.html.erb' do
   let(:display_facet) { double }
   let(:blacklight_config) { Blacklight::Configuration.new }
-  before :each do
+
+  before do
     blacklight_config.add_facet_field 'xyz', label: "Facet title"
     allow(view).to receive(:blacklight_config).and_return(blacklight_config)
     stub_template 'catalog/_facet_pagination.html.erb' => 'pagination'
@@ -14,7 +15,7 @@ describe 'catalog/facet.html.erb' do
   it "has the facet title" do
     allow(view).to receive(:render_facet_limit)
     render
-    expect(rendered).to have_selector 'h3', text: "Facet title"
+    expect(rendered).to have_selector 'h1', text: "Facet title"
   end
 
   it "renders facet pagination" do

data/spec/views/catalog/facet.json.jbuilder_spec.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-describe "catalog/facet.json" do
+
+RSpec.describe "catalog/facet.json", api: true do
   it "renders facet json" do
-    assign :pagination, { items: [{ value: 'Book' }] }
+    assign :pagination, items: [{ value: 'Book' }]
     render template: "catalog/facet.json", format: :json
     hash = JSON.parse(rendered)
     expect(hash).to eq('response' => { 'facets' => { 'items' => [{ 'value' => 'Book' }] } })

data/spec/views/catalog/index.atom.builder_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'rexml/document'
 
-describe "catalog/index" do
+RSpec.describe "catalog/index" do
   let(:document_list) do
     10.times.map do |i|
       doc = SolrDocument.new(id: i)
@@ -13,8 +13,8 @@ describe "catalog/index" do
   end
 
   before do
-    @response = Blacklight::Solr::Response.new({ response: { numFound: 30 }}, { start: 10, rows: 10})
-    @document_list = document_list
+    @response = Blacklight::Solr::Response.new({ response: { numFound: 30 } }, start: 10, rows: 10)
+    allow(@response).to receive(:documents).and_return(document_list)
     params['content_format'] = 'some_format'
     allow(view).to receive(:action_name).and_return('index')
     allow(view).to receive(:blacklight_config).and_return(CatalogController.blacklight_config)
@@ -45,14 +45,14 @@ describe "catalog/index" do
   it "includes an opensearch Query role=request" do
     expect(response_xml.elements.to_a("/feed/opensearch:itemsPerPage")).to have(1).item
     query_el = response_xml.elements["/feed/opensearch:Query"]
-    expect(query_el).to_not be_nil
+    expect(query_el).not_to be_nil
     expect(query_el.attributes["role"]).to eq "request"
     expect(query_el.attributes["searchTerms"]).to eq ""
     expect(query_el.attributes["startPage"]).to eq "2"
   end
 
   it "has ten entries" do
-    expect(rendered).to have_selector("entry", :count => 10)
+    expect(rendered).to have_selector("entry", count: 10)
   end
 
   describe "entries" do
@@ -74,6 +74,7 @@ describe "catalog/index" do
 
     describe "with an author" do
       let(:entry) { response_xml.elements.to_a("/feed/entry")[0] }
+
       it "has author tag" do
         expect(entry.elements["author/name"].text).to eq 'xyz'
       end
@@ -81,6 +82,7 @@ describe "catalog/index" do
 
     describe "without an author" do
       let(:entry) { response_xml.elements.to_a("/feed/entry")[1] }
+
       it "does not have an author tag" do
         expect(entry.elements["author/name"]).to be_nil
       end
@@ -90,6 +92,7 @@ describe "catalog/index" do
   describe "when content_format is specified" do
     describe "for an entry with content available" do
       let(:entry) { response_xml.elements.to_a("/feed/entry")[1].to_s }
+
       it "includes a link rel tag" do
         expect(entry).to have_selector("link[rel=alternate][type='application/some-format']")
       end
@@ -97,10 +100,12 @@ describe "catalog/index" do
         expect(entry).to have_selector("content")
       end
     end
+
     describe "for an entry with NO content available" do
       let(:entry) { response_xml.elements.to_a("/feed/entry")[5].to_s }
+
       it "does not have content embedded" do
-        expect(entry).to_not have_selector("content[type='application/some-format']")
+        expect(entry).not_to have_selector("content[type='application/some-format']")
       end
     end
   end

data/spec/views/catalog/index.html.erb_spec.rb

@@ -1,21 +1,18 @@
 # frozen_string_literal: true
 
-describe "catalog/index.html.erb" do
-
+RSpec.describe "catalog/index.html.erb" do
   describe "with no search parameters" do
     before do
       allow(view).to receive(:has_search_parameters?).and_return(false)
       allow(view).to receive(:blacklight_config).and_return(Blacklight::Configuration.new)
     end
-    it "renders the sidebar and content panes" do
-      render
-      expect(rendered).to match /id="sidebar"/
-      expect(rendered).to match /id="content"/
-    end
+
+    let(:sidebar) { view.content_for(:sidebar) }
+
     it "renders the search_sidebar partial" do
       stub_template "catalog/_search_sidebar.html.erb" => "sidebar_content"
       render
-      expect(rendered).to match /sidebar_content/
+      expect(sidebar).to match /sidebar_content/
     end
   end
 
@@ -28,6 +25,7 @@ describe "catalog/index.html.erb" do
       allow(view).to receive(:render_opensearch_response_metadata).and_return("")
       assign(:response, instance_double(Blacklight::Solr::Response, empty?: true))
     end
+
     it "renders the search_header partial" do
       render
       expect(rendered).to match /header_content/

data/spec/views/catalog/index.json.jbuilder_spec.rb

@@ -1,30 +1,123 @@
 # frozen_string_literal: true
-describe "catalog/index.json" do
-  let(:response) { instance_double(Blacklight::Solr::Response) }
-  let(:docs) { [{ id: '123', title_t: 'Book1' }, { id: '456', title_t: 'Book2' }] }
-  let(:facets) { double("facets") }
-  let(:config) { instance_double(Blacklight::Configuration) }
-  let(:presenter) { Blacklight::JsonPresenter.new(response, docs, facets, config) }
-
-  it "renders index json" do
-    allow(presenter).to receive(:pagination_info).and_return({ current_page: 1, next_page: 2,
-                                                               prev_page: nil })
-    allow(presenter).to receive(:search_facets_as_json).and_return(
-          [{ name: "format", label: "Format",
-             items: [{ value: 'Book', hits: 30, label: 'Book' }] }])
-    assign :presenter, presenter
+
+RSpec.describe "catalog/index.json", api: true do
+  let(:response) { instance_double(Blacklight::Solr::Response, documents: docs, prev_page: nil, next_page: 2, total_pages: 3) }
+  let(:docs) do
+    [
+      SolrDocument.new(id: '123', title_tsim: 'Book1', author_tsim: 'Julie', format: 'Book'),
+      SolrDocument.new(id: '456', title_tsim: 'Article1', author_tsim: 'Rosie', format: 'Article')
+    ]
+  end
+  let(:config) do
+    Blacklight::Configuration.new do |config|
+      config.add_index_field 'title', label: 'Title', field: 'title_tsim'
+    end
+  end
+  let(:presenter) { Blacklight::JsonPresenter.new(response, config) }
+
+  let(:hash) do
     render template: "catalog/index.json", format: :json
-    hash = JSON.parse(rendered)
-    expect(hash).to eq('response' => { 'docs' => [{ 'id' => '123', 'title_t' => 'Book1' },
-                                                  { 'id' => '456', 'title_t' => 'Book2' }],
-                                       'facets' => [{ 'name' => "format", 'label' => "Format",
-                                                      'items' => [
-                                                        { 'value' => 'Book',
-                                                          'hits' => 30,
-                                                          'label' => 'Book' }] }],
-                                       'pages' => { 'current_page' =>  1,
-                                                    'next_page' => 2,
-                                                    'prev_page' => nil } }
-                      )
+    JSON.parse(rendered).with_indifferent_access
+  end
+
+  let(:book_facet_item) do
+    Blacklight::Solr::Response::Facets::FacetItem.new('value' => 'Book', 'hits' => 30, 'label' => 'Book')
+  end
+
+  let(:format_facet) do
+    Blacklight::Solr::Response::Facets::FacetField.new('format',
+                                                       [book_facet_item],
+                                                       'label' => 'Format')
+  end
+
+  before do
+    allow(view).to receive(:blacklight_config).and_return(config)
+    allow(view).to receive(:search_action_path).and_return('http://test.host/some/search/url')
+    allow(view).to receive(:search_facet_path).and_return('http://test.host/some/facet/url')
+    allow(presenter).to receive(:pagination_info).and_return(current_page: 1,
+                                                             next_page: 2,
+                                                             prev_page: nil)
+    allow(presenter).to receive(:search_facets).and_return([format_facet])
+    assign :presenter, presenter
+    assign :response, response
+  end
+
+  it "has pagination links" do
+    expect(hash).to include(links: hash_including(
+      self: 'http://test.host/',
+      next: 'http://test.host/?page=2',
+      last: 'http://test.host/?page=3'
+    ))
+  end
+
+  it "has pagination information" do
+    expect(hash).to include(meta: hash_including(pages:
+      {
+        'current_page' => 1,
+        'next_page' => 2,
+        'prev_page' => nil
+      }))
+  end
+
+  it "includes documents, links, and their attributes" do
+    expect(hash).to include(data: [
+                              {
+                                id: '123',
+                                type: 'Book',
+                                attributes: {
+                                  'title': {
+                                    id: 'http://test.host/catalog/123#title',
+                                    type: 'document_value',
+                                    attributes: {
+                                      value: 'Book1',
+                                      label: 'Title'
+                                    }
+                                  }
+                                },
+                                links: { self: 'http://test.host/catalog/123' }
+                              },
+                              {
+                                id: '456',
+                                type: 'Article',
+                                attributes: {
+                                  'title': {
+                                    id: 'http://test.host/catalog/456#title',
+                                    type: 'document_value',
+                                    attributes: {
+                                      value: 'Article1',
+                                      label: 'Title'
+                                    }
+                                  }
+                                },
+                                links: { self: 'http://test.host/catalog/456' }
+                              }
+                            ])
+  end
+
+  describe 'facets' do
+    let(:facets) { hash[:included].select { |x| x['type'] == 'facet' } }
+    let(:format) { facets.find { |x| x['id'] == 'format' } }
+    let(:format_items) { format['attributes']['items'] }
+    let(:format_item_attributes) { format_items.map { |x| x['attributes'] } }
+
+    context 'when no facets have been selected' do
+      it 'has facet information and links' do
+        expect(facets).to be_present
+        expect(facets.map { |x| x['id'] }).to include 'format'
+        expect(format['links']).to include self: 'http://test.host/some/facet/url'
+        expect(format['attributes']['label']).to eq 'Format'
+        expect(format_item_attributes).to match_array [{ value: 'Book', hits: 30, label: 'Book' }]
+      end
+    end
+
+    context 'when facets have been selected' do
+      before do
+        params[:f] = { format: ['Book'] }
+      end
+
+      it 'has a link to remove the selected value' do
+        expect(format_items.first['links']).to eq('remove' => 'http://test.host/some/search/url')
+      end
+    end
   end
 end

data/spec/views/catalog/opensearch.xml.builder_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe 'catalog/opensearch.xml.builder' do
+RSpec.describe 'catalog/opensearch.xml.builder' do
   it "renders an OpenSearch description document" do
     render
     doc = Nokogiri::XML.parse(rendered)

data/spec/views/catalog/show.html.erb_spec.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
-describe "catalog/show.html.erb" do
-  let(:document) { SolrDocument.new :id => 'xyz', :format => 'a' }
+RSpec.describe "catalog/show.html.erb" do
+  let(:document) { SolrDocument.new id: 'xyz', format: 'a' }
   let(:blacklight_config) { Blacklight::Configuration.new }
 
-  before :each do
+  before do
     allow(view).to receive(:action_name).and_return('show')
-    allow(view).to receive_messages(:has_user_authentication_provider? => false)
-    allow(view).to receive_messages(:render_document_sidebar_partial => "Sidebar")
-    allow(view).to receive_messages(current_search_session: nil)
+    allow(view).to receive_messages(has_user_authentication_provider?: false)
+    allow(view).to receive_messages(render_document_sidebar_partial: "Sidebar")
+    allow(view).to receive_messages(current_search_session: nil, search_session: {})
     assign :document, document
     allow(view).to receive(:blacklight_config).and_return(blacklight_config)
   end
@@ -23,7 +23,7 @@ describe "catalog/show.html.erb" do
 
   it "includes schema.org itemscope/type properties" do
     allow(view).to receive(:document_show_html_title).and_return("Heading")
-    allow(document).to receive_messages(:itemtype => 'some-item-type-uri')
+    allow(document).to receive_messages(itemtype: 'some-item-type-uri')
     render
     expect(rendered).to have_selector('div#document[@itemscope]')
     expect(rendered).to have_selector('div#document[@itemtype="some-item-type-uri"]')
@@ -40,7 +40,7 @@ describe "catalog/show.html.erb" do
 
   it "uses the show.partials parameter to determine the partials to render" do
     allow(view).to receive(:render_grouped_response?).and_return(false)
-    blacklight_config.show.partials = ['a', 'b', 'c']
+    blacklight_config.show.partials = %w[a b c]
     stub_template "catalog/_a_default.html.erb" => "a_partial"
     stub_template "catalog/_b_default.html.erb" => "b_partial"
     stub_template "catalog/_c_default.html.erb" => "c_partial"

data/spec/views/catalog/show.json.jbuilder_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe "catalog/show.json" do
+  let(:document) do
+    SolrDocument.new(id: '123', title_tsim: 'Book1', author_tsim: 'Julie', format: 'Book')
+  end
+  let(:config) do
+    Blacklight::Configuration.new do |config|
+      config.add_show_field 'title', label: 'Title', field: 'title_tsim'
+    end
+  end
+
+  let(:hash) do
+    render template: "catalog/show.json", format: :json
+    JSON.parse(rendered).with_indifferent_access
+  end
+
+  before do
+    allow(view).to receive(:blacklight_config).and_return(config)
+    assign :document, document
+  end
+
+  it "includes document attributes" do
+    expect(hash).to include(data:
+      {
+        id: '123',
+        type: 'Book',
+        attributes: {
+          'title' => {
+            id: 'http://test.host/catalog/123#title',
+            type: 'document_value',
+            attributes: {
+              value: 'Book1',
+              label: 'Title'
+            }
+          }
+        }
+      })
+  end
+end

data/spec/views/catalog/sms_success.html.erb_spec.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+RSpec.describe "catalog/sms_success.html.erb" do
+  it "includes the data-blacklight-modal properties" do
+    render
+    expect(rendered).to have_selector "div[data-blacklight-modal=container]"
+  end
+end

data/spec/views/{_user_util_links.html.erb_spec.rb → shared/_user_util_links.html.erb_spec.rb}

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-describe "_user_util_links" do
-
-  let :blacklight_config do
+RSpec.describe "shared/_user_util_links" do
+  let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
       config.navbar.partials = { bookmark: Blacklight::Configuration::ToolConfig.new(partial: 'blacklight/nav/bookmark', if: :render_bookmarks_control?) }
     end
-
   end
 
   it "renders the correct bookmark count" do
@@ -15,8 +13,7 @@ describe "_user_util_links" do
     allow(controller).to receive(:render_bookmarks_control?).and_return true
     allow(view).to receive(:has_user_authentication_provider?).and_return false
     allow(view).to receive_message_chain(:current_or_guest_user, :bookmarks, :count).and_return(count)
-    render :partial => "user_util_links"
-    expect(rendered).to have_selector('#bookmarks_nav span[data-role=bookmark-counter]', text: "#{count}")
+    render "shared/user_util_links"
+    expect(rendered).to have_selector('#bookmarks_nav span.badge[data-role=bookmark-counter]', text: count.to_s)
   end
-
 end

data/tasks/blacklight.rake

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'solr_wrapper'
 require 'engine_cart/rake_task'
 
 require 'rspec/core/rake_task'
 RSpec::Core::RakeTask.new(:spec) do |t|
-  t.pattern =  'spec/**/*_spec.rb'
+  t.pattern = 'spec/**/*_spec.rb'
 end
 
 require 'rubocop/rake_task'
@@ -12,9 +14,9 @@ RuboCop::RakeTask.new(:rubocop)
 EngineCart.fingerprint_proc = EngineCart.rails_fingerprint_proc
 
 desc "Run test suite"
-task :ci => ['blacklight:generate'] do
+task ci: ['blacklight:generate'] do
   SolrWrapper.wrap do |solr|
-    solr.with_collection(name: 'blacklight-core', dir: File.join(File.expand_path("..", File.dirname(__FILE__)), "solr", "conf")) do
+    solr.with_collection do
       within_test_app do
         system "RAILS_ENV=test rake blacklight:index:seed"
       end
@@ -31,11 +33,11 @@ namespace :blacklight do
   end
 
   desc "Create the test rails app"
-  task :generate => ['engine_cart:generate'] do
+  task generate: ['engine_cart:generate'] do
   end
 
   namespace :internal do
-    task :seed => ['engine_cart:generate'] do
+    task seed: ['engine_cart:generate'] do
       within_test_app do
         system "bundle exec rake blacklight:index:seed"
       end
@@ -43,7 +45,7 @@ namespace :blacklight do
   end
 
   desc 'Run Solr and Blacklight for interactive development'
-  task :server, [:rails_server_args] do |t, args|
+  task :server, [:rails_server_args] do |_t, args|
     if File.exist? EngineCart.destination
       within_test_app do
         system "bundle update"
@@ -52,8 +54,8 @@ namespace :blacklight do
       Rake::Task['engine_cart:generate'].invoke
     end
 
-    SolrWrapper.wrap(port: '8983') do |solr|
-      solr.with_collection(name: 'blacklight-core', dir: File.join(File.expand_path("..", File.dirname(__FILE__)), "solr", "conf")) do
+    SolrWrapper.wrap do |solr|
+      solr.with_collection do
         Rake::Task['blacklight:internal:seed'].invoke
 
         within_test_app do

data/template.demo.rb

@@ -1,21 +1,13 @@
+# frozen_string_literal: true
+
 gem "blacklight", ">= 6.1"
-gem "jettywrapper", ">= 2.0"
-gem 'tzinfo-data', platforms: [:mingw, :mswin, :x64_mingw]
 
 run "bundle install"
 
 # run the blacklight install generator
-options = ENV.fetch("BLACKLIGHT_INSTALL_OPTIONS", '--devise --marc --jettywrapper')
+options = ENV.fetch("BLACKLIGHT_INSTALL_OPTIONS", '--devise --marc --solr_version=latest')
 
 generate 'blacklight:install', options
 
 # run the database migrations
 rake "db:migrate"
-
-# index some data
-if options =~ /jettywrapper/
-  rake "jetty:clean"
-  rake "jetty:start"
-  rake "blacklight:index:seed"
-  rake "jetty:stop"
-end