blacklight 6.14.0 → 7.0.0

data/spec/helpers/{facets_helper_spec.rb → blacklight/facets_helper_behavior_spec.rb}

@@ -1,18 +1,18 @@
 # frozen_string_literal: true
 
-describe FacetsHelper do
+RSpec.describe Blacklight::FacetsHelperBehavior do
   let(:blacklight_config) { Blacklight::Configuration.new }
 
-  before(:each) do
+  before do
     allow(helper).to receive(:blacklight_config).and_return blacklight_config
   end
 
   describe "has_facet_values?" do
-    let(:empty) { double(:items => [], :name => 'empty') }
+    let(:empty) { double(items: [], name: 'empty') }
 
     it "is true if there are any facets to display" do
-      a = double(:items => [1, 2], :name => 'a')
-      b = double(:items => ['b', 'c'], :name => 'b')
+      a = double(items: [1, 2], name: 'a')
+      b = double(items: %w[b c], name: 'b')
       fields = [a, b, empty]
       expect(helper.has_facet_values?(fields)).to be true
     end
@@ -22,9 +22,10 @@ describe FacetsHelper do
     end
 
     describe "different config" do
-      let(:blacklight_config) { Blacklight::Configuration.new { |config| config.add_facet_field 'basic_field', :if => false } }
+      let(:blacklight_config) { Blacklight::Configuration.new { |config| config.add_facet_field 'basic_field', if: false } }
+
       it "is false if no facets are displayable" do
-        a = double(:items => [1, 2], :name => 'basic_field')
+        a = double(items: [1, 2], name: 'basic_field')
         expect(helper.has_facet_values?([a])).to be false
       end
     end
@@ -34,45 +35,45 @@ describe FacetsHelper do
     let(:blacklight_config) do
       Blacklight::Configuration.new do |config|
         config.add_facet_field 'basic_field'
-        config.add_facet_field 'no_show', :show => false
-        config.add_facet_field 'helper_show', :show => :my_custom_check
-        config.add_facet_field 'helper_with_an_arg_show', :show => :my_custom_check_with_an_arg
-        config.add_facet_field 'lambda_show',    :show => lambda { |context, config, field| true }
-        config.add_facet_field 'lambda_no_show', :show => lambda { |context, config, field| false }
+        config.add_facet_field 'no_show', show: false
+        config.add_facet_field 'helper_show', show: :my_custom_check
+        config.add_facet_field 'helper_with_an_arg_show', show: :my_custom_check_with_an_arg
+        config.add_facet_field 'lambda_show',    show: ->(_context, _config, _field) { true }
+        config.add_facet_field 'lambda_no_show', show: ->(_context, _config, _field) { false }
       end
     end
 
     it "renders facets with items" do
-      a = double(:items => [1, 2], :name => 'basic_field')
+      a = double(items: [1, 2], name: 'basic_field')
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "does not render facets without items" do
-      empty = double(:items => [], :name => 'basic_field')
+      empty = double(items: [], name: 'basic_field')
       expect(helper.should_render_facet?(empty)).to be false
     end
 
     it "does not render facets where show is set to false" do
-      a = double(:items => [1, 2], :name => 'no_show')
+      a = double(items: [1, 2], name: 'no_show')
       expect(helper.should_render_facet?(a)).to be false
     end
 
     it "calls a helper to determine if it should render a field" do
-      allow(controller).to receive_messages(:my_custom_check => true)
-      a = double(:items => [1, 2], :name => 'helper_show')
+      allow(controller).to receive_messages(my_custom_check: true)
+      a = double(items: [1, 2], name: 'helper_show')
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "calls a helper to determine if it should render a field" do
-      a = double(:items => [1, 2], :name => 'helper_with_an_arg_show')
+      a = double(items: [1, 2], name: 'helper_with_an_arg_show')
       allow(controller).to receive(:my_custom_check_with_an_arg).with(blacklight_config.facet_fields['helper_with_an_arg_show'], a).and_return(true)
       expect(helper.should_render_facet?(a)).to be true
     end
 
     it "evaluates a Proc to determine if it should render a field" do
-      a = double(:items => [1, 2], :name => 'lambda_show')
+      a = double(items: [1, 2], name: 'lambda_show')
       expect(helper.should_render_facet?(a)).to be true
-      a = double(:items => [1, 2], :name => 'lambda_no_show')
+      a = double(items: [1, 2], name: 'lambda_no_show')
       expect(helper.should_render_facet?(a)).to be false
     end
   end
@@ -103,7 +104,7 @@ describe FacetsHelper do
   describe "facet_by_field_name" do
     it "retrieves the facet from the response given a string" do
       facet_config = double(query: nil, field: 'b', key: 'a')
-      facet_field = double()
+      facet_field = double
       allow(helper).to receive(:facet_configuration_for_field).with('b').and_return(facet_config)
       @response = instance_double(Blacklight::Solr::Response, aggregations: { 'b' => facet_field })
 
@@ -112,11 +113,11 @@ describe FacetsHelper do
   end
 
   describe "render_facet_partials" do
-    let(:a) { double(:items => [1, 2]) }
-    let(:b) { double(:items => ['b', 'c']) }
+    let(:a) { double(items: [1, 2]) }
+    let(:b) { double(items: %w[b c]) }
 
     it "tries to render all provided facets" do
-      empty = double(:items => [])
+      empty = double(items: [])
       fields = [a, b, empty]
       expect(helper).to receive(:render_facet_limit).with(a, {})
       expect(helper).to receive(:render_facet_limit).with(b, {})
@@ -136,64 +137,65 @@ describe FacetsHelper do
     let(:blacklight_config) do
       Blacklight::Configuration.new do |config|
         config.add_facet_field 'basic_field'
-        config.add_facet_field 'pivot_facet_field', :pivot => ['a', 'b']
-        config.add_facet_field 'my_pivot_facet_field_with_custom_partial', :partial => 'custom_facet_partial', :pivot => ['a', 'b']
-        config.add_facet_field 'my_facet_field_with_custom_partial', :partial => 'custom_facet_partial'
+        config.add_facet_field 'pivot_facet_field', pivot: %w[a b]
+        config.add_facet_field 'my_pivot_facet_field_with_custom_partial', partial: 'custom_facet_partial', pivot: %w[a b]
+        config.add_facet_field 'my_facet_field_with_custom_partial', partial: 'custom_facet_partial'
       end
     end
-    let(:mock_custom_facet) { double(:name => 'my_facet_field_with_custom_partial', :items => [1, 2, 3]) }
+    let(:mock_custom_facet) { double(name: 'my_facet_field_with_custom_partial', items: [1, 2, 3]) }
 
     it "sets basic local variables" do
-      mock_facet = double(:name => 'basic_field', :items => [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_limit',
-                                                             :locals => {
-                                                                :solr_field => 'basic_field',
-                                                                :field_name => 'basic_field',
-                                                                :facet_field => helper.blacklight_config.facet_fields['basic_field'],
-                                                                :display_facet => mock_facet  }
-                                                            ))
+      mock_facet = double(name: 'basic_field', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'facet_limit',
+                                                             locals: {
+                                                               field_name: 'basic_field',
+                                                               facet_field: helper.blacklight_config.facet_fields['basic_field'],
+                                                               display_facet: mock_facet
+                                                             }))
       helper.render_facet_limit(mock_facet)
     end
 
     it "renders a facet _not_ declared in the configuration" do
-      mock_facet = double(:name => 'asdf', :items => [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_limit'))
+      mock_facet = double(name: 'asdf', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'facet_limit'))
       helper.render_facet_limit(mock_facet)
     end
 
     it "gets the partial name from the configuration" do
-      expect(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
+      expect(helper).to receive(:render).with(hash_including(partial: 'custom_facet_partial'))
       helper.render_facet_limit(mock_custom_facet)
     end
 
     it "uses a partial layout for rendering the facet frame" do
-      expect(helper).to receive(:render).with(hash_including(:layout => 'facet_layout'))
+      expect(helper).to receive(:render).with(hash_including(layout: 'facet_layout'))
       helper.render_facet_limit(mock_custom_facet)
     end
 
     it "allows the caller to opt-out of facet layouts" do
-      expect(helper).to receive(:render).with(hash_including(:layout => nil))
-      helper.render_facet_limit(mock_custom_facet, :layout => nil)
+      expect(helper).to receive(:render).with(hash_including(layout: nil))
+      helper.render_facet_limit(mock_custom_facet, layout: nil)
     end
 
     it "renders the facet_pivot partial for pivot facets" do
-      mock_facet = double(:name => 'pivot_facet_field', :items => [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'facet_pivot'))
+      mock_facet = double(name: 'pivot_facet_field', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'facet_pivot'))
       helper.render_facet_limit(mock_facet)
     end
 
     it "lets you override the rendered partial for pivot facets" do
-      mock_facet = double(:name => 'my_pivot_facet_field_with_custom_partial', :items => [1, 2, 3])
-      expect(helper).to receive(:render).with(hash_including(:partial => 'custom_facet_partial'))
+      mock_facet = double(name: 'my_pivot_facet_field_with_custom_partial', items: [1, 2, 3])
+      expect(helper).to receive(:render).with(hash_including(partial: 'custom_facet_partial'))
       helper.render_facet_limit(mock_facet)
     end
   end
 
   describe "render_facet_limit_list" do
+    subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
+
     let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
     let(:f2) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
     let(:paginator) { Blacklight::Solr::FacetPaginator.new([f1, f2], limit: 10) }
-    subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
+
     before do
       allow(helper).to receive(:search_action_path) do |*args|
         search_catalog_path *args
@@ -202,38 +204,38 @@ describe FacetsHelper do
 
     it "draws a list of elements" do
       expect(subject).to have_selector 'li', count: 2
-      expect(subject).to have_selector 'li:first-child a.facet_select', text: 'Book'
-      expect(subject).to have_selector 'li:nth-child(2) a.facet_select', text: 'Musical Score'
+      expect(subject).to have_selector 'li:first-child a.facet-select', text: 'Book'
+      expect(subject).to have_selector 'li:nth-child(2) a.facet-select', text: 'Musical Score'
     end
 
     context "when one of the facet items is rendered as nil" do
       # An app may override render_facet_item to filter out some undesired facet items by returning nil.
-      before { allow(helper).to receive(:render_facet_item).and_return('<a class="facet_select">Book</a>'.html_safe, nil) }
+      before { allow(helper).to receive(:render_facet_item).and_return('<a class="facet-select">Book</a>'.html_safe, nil) }
 
       it "draws a list of elements" do
         expect(subject).to have_selector 'li', count: 1
-        expect(subject).to have_selector 'li:first-child a.facet_select', text: 'Book'
+        expect(subject).to have_selector 'li:first-child a.facet-select', text: 'Book'
       end
     end
   end
 
   describe "facet_field_in_params?" do
     it "checks if the facet field is selected in the user params" do
-      allow(helper).to receive_messages(:params => { :f => { "some-field" => ["x"]}})
-      expect(helper.facet_field_in_params?("some-field")).to be_truthy
-      expect(helper.facet_field_in_params?("other-field")).to_not be true
+      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] } })
+      expect(helper).to be_facet_field_in_params("some-field")
+      expect(helper.facet_field_in_params?("other-field")).not_to be true
     end
   end
 
   describe "facet_params" do
     it "extracts the facet parameters for a field" do
-      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] }})
+      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] } })
       expect(helper.facet_params("some-field")).to match_array ["x"]
     end
 
     it "uses the blacklight key to extract the right fields" do
       blacklight_config.add_facet_field "some-key", field: "some-field"
-      allow(helper).to receive_messages(params: { f: { "some-key" => ["x"] }})
+      allow(helper).to receive_messages(params: { f: { "some-key" => ["x"] } })
       expect(helper.facet_params("some-key")).to match_array ["x"]
       expect(helper.facet_params("some-field")).to match_array ["x"]
     end
@@ -265,10 +267,11 @@ describe FacetsHelper do
   end
 
   describe "render_facet_value" do
-    let(:item) { double(:value => 'A', :hits => 10) }
+    let(:item) { double(value: 'A', hits: 10) }
     let(:search_state) { double(add_facet_params_and_redirect: { controller: 'catalog' }) }
+
     before do
-      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, single: false, url_method: nil))
       allow(helper).to receive(:facet_display_value).and_return('Z')
       allow(helper).to receive(:search_state).and_return(search_state)
       allow(helper).to receive(:search_action_path) do |*args|
@@ -277,7 +280,7 @@ describe FacetsHelper do
     end
 
     describe "simple case" do
-      let(:expected_html) { '<span class="facet-label"><a class="facet_select" href="/catalog">Z</a></span><span class="facet-count">10</span>' }
+      let(:expected_html) { '<span class="facet-label"><a class="facet-select" href="/catalog">Z</a></span><span class="facet-count">10</span>' }
 
       it "uses facet_display_value" do
         result = helper.render_facet_value('simple_field', item)
@@ -286,9 +289,10 @@ describe FacetsHelper do
     end
 
     describe "when :url_method is set" do
-      let(:expected_html) { '<span class="facet-label"><a class="facet_select" href="/blabla">Z</a></span><span class="facet-count">10</span>' }
+      let(:expected_html) { '<span class="facet-label"><a class="facet-select" href="/blabla">Z</a></span><span class="facet-count">10</span>' }
+
       it "uses that method" do
-        allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :single => false, :url_method => :test_method))
+        allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, single: false, url_method: :test_method))
         allow(helper).to receive(:test_method).with('simple_field', item).and_return('/blabla')
         result = helper.render_facet_value('simple_field', item)
         expect(result).to be_equivalent_to(expected_html).respecting_element_order
@@ -297,8 +301,9 @@ describe FacetsHelper do
 
     describe "when :suppress_link is set" do
       let(:expected_html) { '<span class="facet-label">Z</span><span class="facet-count">10</span>' }
+
       it "suppresses the link" do
-        result = helper.render_facet_value('simple_field', item, :suppress_link => true)
+        result = helper.render_facet_value('simple_field', item, suppress_link: true)
         expect(result).to be_equivalent_to(expected_html).respecting_element_order
       end
     end
@@ -306,18 +311,18 @@ describe FacetsHelper do
 
   describe "#facet_display_value" do
     it "justs be the facet value for an ordinary facet" do
-      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(:query => nil, :date => nil, :helper_method => nil, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('simple_field').and_return(double(query: nil, date: nil, helper_method: nil, url_method: nil))
       expect(helper.facet_display_value('simple_field', 'asdf')).to eq 'asdf'
     end
 
     it "allows you to pass in a :helper_method argument to the configuration" do
-      allow(helper).to receive(:facet_configuration_for_field).with('helper_field').and_return(double(:query => nil, :date => nil, :url_method => nil, :helper_method => :my_facet_value_renderer))
+      allow(helper).to receive(:facet_configuration_for_field).with('helper_field').and_return(double(query: nil, date: nil, url_method: nil, helper_method: :my_facet_value_renderer))
       allow(helper).to receive(:my_facet_value_renderer).with('qwerty').and_return('abc')
       expect(helper.facet_display_value('helper_field', 'qwerty')).to eq 'abc'
     end
 
     it "extracts the configuration label for a query facet" do
-      allow(helper).to receive(:facet_configuration_for_field).with('query_facet').and_return(double(:query => { 'query_key' => { :label => 'XYZ'}}, :date => nil, :helper_method => nil, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('query_facet').and_return(double(query: { 'query_key' => { label: 'XYZ' } }, date: nil, helper_method: nil, url_method: nil))
       expect(helper.facet_display_value('query_facet', 'query_key')).to eq 'XYZ'
     end
 
@@ -327,14 +332,14 @@ describe FacetsHelper do
     end
 
     it "localizes the label for date-type facets with the supplied localization options" do
-      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => { :format => :short }, :query => nil, :helper_method => nil, :url_method => nil))
+      allow(helper).to receive(:facet_configuration_for_field).with('date_facet').and_return(double('date' => { format: :short }, :query => nil, :helper_method => nil, :url_method => nil))
       expect(helper.facet_display_value('date_facet', '2012-01-01')).to eq '01 Jan 00:00'
     end
   end
 
   describe "#facet_field_id" do
     it "is the parameterized version of the facet field" do
-      expect(helper.facet_field_id double(key: 'some field')).to eq "facet-some-field"
+      expect(helper.facet_field_id(double(key: 'some field'))).to eq "facet-some-field"
     end
   end
 end

data/spec/helpers/{hash_as_hidden_fields_spec.rb → blacklight/hash_as_hidden_fields_behavior_spec.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-describe Blacklight::HashAsHiddenFieldsHelperBehavior do
+RSpec.describe Blacklight::HashAsHiddenFieldsHelperBehavior do
   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"] } }
+      f: { field1: %w[a b], field2: ["z"] } }
   end
   let(:generated) { helper.render_hash_as_hidden_fields(params) }
 

data/spec/helpers/blacklight/icon_helper_behavior_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::IconHelperBehavior do
+  describe '#blacklight_icon' do
+    it 'wraps the svg in a span with classes' do
+      expect(helper.blacklight_icon(:search))
+        .to have_css 'span.blacklight-icons svg'
+    end
+  end
+end

data/spec/helpers/{layout_helper_spec.rb → blacklight/layout_helper_behavior_spec.rb}

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-describe LayoutHelper do
+RSpec.describe Blacklight::LayoutHelperBehavior do
   describe '#show_content_classes' do
     it 'returns a string of classes' do
       expect(helper.show_content_classes).to be_an String
-      expect(helper.show_content_classes).to eq 'col-md-9 col-sm-8 show-document'
+      expect(helper.show_content_classes).to eq 'col-md-9 show-document'
     end
   end
 
   describe '#show_sidebar_classes' do
     it 'returns a string of classes' do
       expect(helper.show_sidebar_classes).to be_an String
-      expect(helper.show_sidebar_classes).to eq 'col-md-3 col-sm-4'
+      expect(helper.show_sidebar_classes).to eq 'page-sidebar col-md-3'
     end
   end
 
   describe '#main_content_classes' do
     it 'returns a string of classes' do
       expect(helper.main_content_classes).to be_an String
-      expect(helper.main_content_classes).to eq 'col-md-9 col-sm-8'
+      expect(helper.main_content_classes).to eq 'col-md-9'
     end
   end
 
   describe '#sidebar_classes' do
     it 'returns a string of classes' do
       expect(helper.sidebar_classes).to be_an String
-      expect(helper.sidebar_classes).to eq 'col-md-3 col-sm-4'
+      expect(helper.sidebar_classes).to eq 'page-sidebar col-md-3'
     end
   end
 

data/spec/helpers/{render_constraints_helper_spec.rb → blacklight/render_constraints_helper_behavior_spec.rb}

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
-describe RenderConstraintsHelper do
-
+RSpec.describe Blacklight::RenderConstraintsHelperBehavior do
   let(:config) do
     Blacklight::Configuration.new do |config|
       config.add_facet_field 'type'
@@ -17,9 +16,10 @@ describe RenderConstraintsHelper do
   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' }) }
-    subject { helper.render_constraints_query(params) }
 
     it "has a link relative to the current url" do
       expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
@@ -35,6 +35,7 @@ describe RenderConstraintsHelper do
 
     context "with a route_set" do
       let(:params) { ActionController::Parameters.new(q: 'foobar', f: { type: 'journal' }, route_set: my_engine) }
+
       it "accepts an optional route set" do
         expect(my_engine).to receive(:url_for).and_return('/?f%5Btype%5D=journal')
         expect(subject).to have_selector "a[href='/?f%5Btype%5D=journal']"
@@ -43,18 +44,19 @@ describe RenderConstraintsHelper do
   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
-    subject { helper.render_filter_element('type', ['journal'], path) }
 
     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 ".filterName", text: 'Item Type'
+      expect(subject).to have_selector ".filter-name", text: 'Item Type'
     end
 
     context 'with string values' do
@@ -67,12 +69,14 @@ describe RenderConstraintsHelper do
   end
 
   describe "#render_constraints_filters" do
+    subject { helper.render_constraints_filters(params) }
+
     let(:params) { ActionController::Parameters.new f: { 'type' => [''] } }
+
     before do
       allow(helper).to receive(:blacklight_config).and_return(config)
       allow(controller).to receive(:search_state_class).and_return(Blacklight::SearchState)
     end
-    subject { helper.render_constraints_filters(params) }
 
     it "renders nothing for empty facet limit param" do
       expect(subject).to be_blank

data/spec/helpers/blacklight/render_partials_helper_behavior_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::RenderPartialsHelperBehavior do
+  describe "#type_field_to_partial_name" do
+    subject { helper.send(:type_field_to_partial_name, document, value) }
+
+    let(:document) { double }
+
+    context "with default value" do
+      let(:value) { 'default' }
+
+      it { is_expected.to eq 'default' }
+    end
+
+    context "with spaces" do
+      let(:value) { 'one two three' }
+
+      it { is_expected.to eq 'one_two_three' }
+    end
+
+    context "with hyphens" do
+      let(:value) { 'one-two-three' }
+
+      it { is_expected.to eq 'one_two_three' }
+    end
+
+    context "an array" do
+      let(:value) { %w[one two three] }
+
+      it { is_expected.to eq 'one_two_three' }
+    end
+  end
+
+  describe "#render_document_partials" do
+    let(:doc) { double }
+
+    before do
+      allow(helper).to receive_messages(document_partial_path_templates: [])
+      allow(helper).to receive_messages(document_index_view_type: 'index_header')
+    end
+
+    it "gets the document format from document_partial_name" do
+      allow(helper).to receive(:document_partial_name).with(doc, :xyz)
+      helper.render_document_partial(doc, :xyz)
+    end
+  end
+
+  describe "#document_partial_name" do
+    let(:blacklight_config) { Blacklight::Configuration.new }
+
+    before do
+      allow(helper).to receive_messages(blacklight_config: blacklight_config)
+    end
+
+    context "with a solr document with empty fields" do
+      let(:document) { SolrDocument.new }
+
+      it "is the default value" do
+        expect(helper.document_partial_name(document)).to eq 'default'
+      end
+    end
+
+    context "with a solr document with the display type field set" do
+      let(:document) { SolrDocument.new 'my_field' => 'xyz' }
+
+      before do
+        blacklight_config.show.display_type_field = 'my_field'
+      end
+
+      it "uses the value in the configured display type field" do
+        expect(helper.document_partial_name(document)).to eq 'xyz'
+      end
+      it "uses the value in the configured display type field if the action-specific field is empty" do
+        expect(helper.document_partial_name(document, :some_action)).to eq 'xyz'
+      end
+    end
+
+    context "with a solr doucment with an action-specific field set" do
+      let(:document) { SolrDocument.new 'my_field' => 'xyz', 'other_field' => 'abc' }
+
+      before do
+        blacklight_config.show.media_display_type_field = 'my_field'
+        blacklight_config.show.metadata_display_type_field = 'other_field'
+      end
+
+      it "uses the value in the action-specific fields" do
+        expect(helper.document_partial_name(document, :media)).to eq 'xyz'
+        expect(helper.document_partial_name(document, :metadata)).to eq 'abc'
+      end
+    end
+  end
+end