blacklight-spotlight 0.4.1 → 0.5.0

data/spec/helpers/spotlight/browse_helper_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Spotlight::BrowseHelper, :type => :helper do
-  it "should default to the gallery" do
-    allow(helper).to receive_messages(blacklight_config: double(view: {:gallery => true}))
+describe Spotlight::BrowseHelper, type: :helper do
+  it 'defaults to the gallery' do
+    allow(helper).to receive_messages(blacklight_config: double(view: { gallery: true }))
     expect(helper.default_document_index_view_type).to eq :gallery
   end
-  
-  it "should use the blacklight default if gallery isn't available" do
-    allow(helper).to receive_messages(blacklight_config: double(view: { :list => true }))
+
+  it "uses the blacklight default if gallery isn't available" do
+    allow(helper).to receive_messages(blacklight_config: double(view: { list: true }))
     expect(helper.default_document_index_view_type).to eq :list
   end
 end

data/spec/helpers/spotlight/crud_link_helpers_spec.rb

@@ -1,126 +1,132 @@
 require 'spec_helper'
 
 module Spotlight
-  describe CrudLinkHelpers, :type => :helper do
+  describe CrudLinkHelpers, type: :helper do
     let(:exhibit) { FactoryGirl.create(:exhibit) }
     let(:some_model) { Spotlight::FeaturePage.create! exhibit: exhibit }
-    describe "#cancel_link" do
-
-      it "should be a model-specific cancel link" do
-        expect(helper).to receive(:action_default_value).with(:my_model, :cancel).and_return "Cancel"
-        expect(helper.cancel_link(:my_model, "#")).to have_link "Cancel", href: "#"
+    describe '#cancel_link' do
+      it 'is a model-specific cancel link' do
+        expect(helper).to receive(:action_default_value).with(:my_model, :cancel).and_return 'Cancel'
+        expect(helper.cancel_link(:my_model, '#')).to have_link 'Cancel', href: '#'
       end
     end
 
-    describe "#exhibit_view_link" do
+    describe '#exhibit_view_link' do
       before do
-        allow(helper).to receive_messages action_default_value: "View"
+        allow(helper).to receive_messages action_default_value: 'View'
       end
 
-      it "should be a model-specific view link" do
-        expect(helper).to receive(:action_default_value).with(some_model, :view).and_return "View"
-        expect(helper.exhibit_view_link(some_model)).to have_link "View", href: spotlight.exhibit_feature_page_path(some_model.exhibit, some_model)
+      it 'is a model-specific view link' do
+        expect(helper).to receive(:action_default_value).with(some_model, :view).and_return 'View'
+        expect(helper.exhibit_view_link(some_model)).to have_link 'View', href: spotlight.exhibit_feature_page_path(some_model.exhibit, some_model)
       end
 
-      it "should accept an explicit link" do
-        expect(helper.exhibit_view_link(some_model, '#')).to have_link "View", href: "#"
+      it 'accepts an explicit link' do
+        expect(helper.exhibit_view_link(some_model, '#')).to have_link 'View', href: '#'
       end
 
-      it "should accept link_to options" do
+      it 'accepts link_to options' do
         expect(helper.exhibit_view_link(some_model, '#', class: 'btn')).to have_selector 'a.btn'
       end
     end
 
-    describe "#exhibit_create_link" do
+    describe '#exhibit_create_link' do
       let(:some_model) { Spotlight::FeaturePage.new }
       before do
         allow(helper).to receive_messages(current_exhibit: exhibit)
-        allow(helper).to receive_messages action_default_value: "Create"
+        allow(helper).to receive_messages action_default_value: 'Create'
       end
 
-      it "should be a model-specific view link" do
-        expect(helper).to receive(:action_default_value).with(some_model).and_return "Create"
-        expect(helper.exhibit_create_link(some_model)).to have_link "Create", href: spotlight.new_exhibit_feature_page_path(exhibit)
+      it 'is a model-specific view link' do
+        expect(helper).to receive(:action_default_value).with(some_model).and_return 'Create'
+        expect(helper.exhibit_create_link(some_model)).to have_link 'Create', href: spotlight.new_exhibit_feature_page_path(exhibit)
       end
 
-      it "should accept an explicit link" do
-        expect(helper.exhibit_create_link(some_model, '#')).to have_link "Create", href: "#"
+      it 'accepts an explicit link' do
+        expect(helper.exhibit_create_link(some_model, '#')).to have_link 'Create', href: '#'
       end
 
-      it "should accept link_to options" do
+      it 'accepts link_to options' do
         expect(helper.exhibit_create_link(some_model, '#', class: 'btn')).to have_selector 'a.btn'
       end
     end
 
-    describe "#exhibit_edit_link" do
+    describe '#exhibit_edit_link' do
       let(:some_model) { Spotlight::FeaturePage.create! exhibit: exhibit }
       before do
         allow(helper).to receive_messages(current_exhibit: exhibit)
-        allow(helper).to receive_messages action_default_value: "Edit"
+        allow(helper).to receive_messages action_default_value: 'Edit'
       end
 
-      it "should be a model-specific edit link" do
-        expect(helper).to receive(:action_default_value).with(some_model).and_return "Edit"
-        expect(helper.exhibit_edit_link(some_model)).to have_link "Edit", href: spotlight.edit_exhibit_feature_page_path(exhibit, some_model)
+      it 'is a model-specific edit link' do
+        expect(helper).to receive(:action_default_value).with(some_model).and_return 'Edit'
+        expect(helper.exhibit_edit_link(some_model)).to have_link 'Edit', href: spotlight.edit_exhibit_feature_page_path(exhibit, some_model)
       end
 
-      it "should accept an explicit link" do
-        expect(helper.exhibit_edit_link(some_model, '#')).to have_link "Edit", href: "#"
+      it 'accepts an explicit link' do
+        expect(helper.exhibit_edit_link(some_model, '#')).to have_link 'Edit', href: '#'
       end
 
-      it "should accept link_to options" do
+      it 'accepts link_to options' do
         expect(helper.exhibit_edit_link(some_model, '#', class: 'btn')).to have_selector 'a.btn'
       end
     end
 
-    describe "#exhibit_delete_link" do
+    describe '#exhibit_delete_link' do
       before do
-        allow(helper).to receive_messages action_default_value: "Delete"
+        allow(helper).to receive_messages action_default_value: 'Delete'
       end
 
-      it "should be a model-specific view link" do
-        expect(helper).to receive(:action_default_value).with(some_model, :destroy).and_return "Delete"
-        expect(helper.exhibit_delete_link(some_model)).to have_link "Delete", href: spotlight.exhibit_feature_page_path(some_model.exhibit, some_model)
+      it 'is a model-specific view link' do
+        expect(helper).to receive(:action_default_value).with(some_model, :destroy).and_return 'Delete'
+        expect(helper.exhibit_delete_link(some_model)).to have_link 'Delete', href: spotlight.exhibit_feature_page_path(some_model.exhibit, some_model)
       end
 
-      it "should accept an explicit link" do
-        expect(helper.exhibit_delete_link(some_model, '#')).to have_link "Delete", href: "#"
+      it 'accepts an explicit link' do
+        expect(helper.exhibit_delete_link(some_model, '#')).to have_link 'Delete', href: '#'
       end
 
-      it "should accept link_to options" do
+      it 'accepts link_to options' do
         expect(helper.exhibit_delete_link(some_model, '#', class: 'btn')).to have_selector 'a.btn'
       end
     end
 
-    describe "#action_label" do
-      it "should return the label for an action on a model" do
+    describe '#action_label' do
+      it 'returns the label for an action on a model' do
         some_model = double
-        expect(helper).to receive(:action_default_value).with(some_model, :action).and_return "xyz"
-        expect(helper.action_label(some_model, :action)).to eq "xyz"
+        expect(helper).to receive(:action_default_value).with(some_model, :action).and_return 'xyz'
+        expect(helper.action_label(some_model, :action)).to eq 'xyz'
       end
     end
 
-    describe "#action_default_value" do
-      it "should attempt i18n lookups for models" do
-        expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.edit', model: some_model.class.model_name.human, default: [:'helpers.action.edit', 'Edit Feature page'])
+    describe '#action_default_value' do
+      it 'attempts i18n lookups for models' do
+        expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.edit',
+                                         model: some_model.class.model_name.human,
+                                         default: [:'helpers.action.edit', 'Edit Feature page'])
         expect(helper.send(:action_default_value, some_model))
       end
 
-      it "should attempt i18n lookups for unpersisted models" do
+      it 'attempts i18n lookups for unpersisted models' do
         some_model = Spotlight::FeaturePage.new
-        expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.create', model: some_model.class.model_name.human, default: [:'helpers.action.create', 'Create Feature page'])
+        expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.create',
+                                         model: some_model.class.model_name.human,
+                                         default: [:'helpers.action.create', 'Create Feature page'])
         expect(helper.send(:action_default_value, some_model))
       end
 
-      it "should attempt i18n lookups for models with an explicit action" do
-        expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.custom_action', model: some_model.class.model_name.human, default: [:'helpers.action.custom_action', 'Custom action Feature page'])
+      it 'attempts i18n lookups for models with an explicit action' do
+        expect(I18n).to receive(:t).with(:'helpers.action.spotlight/feature_page.custom_action',
+                                         model: some_model.class.model_name.human,
+                                         default: [:'helpers.action.custom_action', 'Custom action Feature page'])
         expect(helper.send(:action_default_value, some_model, :custom_action))
       end
 
-      it "should attempt i18n lookups for symbols" do
-        expect(I18n).to receive(:t).with(:'helpers.action.my_thing.custom_action', model: :my_thing, default: [:'helpers.action.custom_action', 'Custom action my_thing'])
+      it 'attempts i18n lookups for symbols' do
+        expect(I18n).to receive(:t).with(:'helpers.action.my_thing.custom_action',
+                                         model: :my_thing,
+                                         default: [:'helpers.action.custom_action', 'Custom action my_thing'])
         expect(helper.send(:action_default_value, :my_thing, :custom_action))
-
       end
     end
   end

data/spec/helpers/spotlight/main_app_helpers_spec.rb

@@ -1,30 +1,36 @@
 require 'spec_helper'
 
-describe Spotlight::MainAppHelpers, :type => :helper do
-  
-  describe "#show_contact_form?" do
+describe Spotlight::MainAppHelpers, type: :helper do
+  describe '#show_contact_form?' do
     subject { helper }
     let(:exhibit) { FactoryGirl.create :exhibit }
     let(:exhibit_with_contacts) { FactoryGirl.create :exhibit }
-    context "with an exhibit with confirmed contacts" do
-      before { exhibit_with_contacts.contact_emails.create(email: 'cabeer@stanford.edu').confirm! }
+    context 'with an exhibit with confirmed contacts' do
+      before do
+        exhibit_with_contacts.contact_emails.create(email: 'cabeer@stanford.edu').tap do |e|
+          if e.respond_to? :confirm
+            e.confirm
+          else
+            e.confirm!
+          end
+        end
+      end
       before { allow(helper).to receive_messages current_exhibit: exhibit_with_contacts }
       its(:show_contact_form?) { should be_truthy }
     end
 
-    context "with an exhibit with only unconfirmed contacts" do
+    context 'with an exhibit with only unconfirmed contacts' do
       before { exhibit_with_contacts.contact_emails.build email: 'cabeer@stanford.edu' }
       before { allow(helper).to receive_messages current_exhibit: exhibit_with_contacts }
       its(:show_contact_form?) { should be_falsey }
     end
-    
-    
-    context "with an exhibit without contacts" do
+
+    context 'with an exhibit without contacts' do
       before { allow(helper).to receive_messages current_exhibit: exhibit }
       its(:show_contact_form?) { should be_falsey }
     end
-    
-    context "outside the context of an exhibit" do
+
+    context 'outside the context of an exhibit' do
       before { allow(helper).to receive_messages current_exhibit: nil }
       its(:show_contact_form?) { should be_falsey }
     end
@@ -38,23 +44,38 @@ describe Spotlight::MainAppHelpers, :type => :helper do
       allow(helper).to receive(:controller).and_return(controller)
       allow(helper).to receive(:document_index_view_type).and_return(nil)
       allow(field).to receive(:enabled).and_return(true)
-      allow(field).to receive(:show).and_return(:value)
     end
-    it 'should return the value of field#show if the action_name is "show"' do
-      allow(helper).to receive(:action_name).and_return("show")
+    context 'for sort fields' do
+      let(:field) { Blacklight::Configuration::SortField.new enabled: true }
+      it 'uses the enabled property for sort fields' do
+        expect(helper.field_enabled?(field)).to eq true
+      end
+    end
+
+    context 'for search fields' do
+      let(:field) { Blacklight::Configuration::SearchField.new enabled: true }
+      it 'uses the enabled property for search fields' do
+        expect(helper.field_enabled?(field)).to eq true
+      end
+    end
+
+    it 'returns the value of field#show if the action_name is "show"' do
+      allow(field).to receive(:show).and_return(:value)
+      allow(helper).to receive(:action_name).and_return('show')
       expect(helper.field_enabled?(field)).to eq :value
     end
-    it 'should return the value of field#show if the action_name is "edit"' do
-      allow(helper).to receive(:action_name).and_return("edit")
+    it 'returns the value of field#show if the action_name is "edit"' do
+      allow(field).to receive(:show).and_return(:value)
+      allow(helper).to receive(:action_name).and_return('edit')
       expect(helper.field_enabled?(field)).to eq :value
     end
-    it "should return the value of the original if condition" do
+    it 'returns the value of the original if condition' do
       allow(field).to receive(:upstream_if).and_return false
-      expect(helper.field_enabled?(field)).to eq false 
+      expect(helper.field_enabled?(field)).to eq false
     end
   end
 
-  describe "#enabled_in_spotlight_view_type_configuration?" do
+  describe '#enabled_in_spotlight_view_type_configuration?' do
     let(:controller) { OpenStruct.new }
     let(:view) { OpenStruct.new }
     before do
@@ -62,21 +83,20 @@ describe Spotlight::MainAppHelpers, :type => :helper do
       allow(helper).to receive(:controller).and_return(controller)
     end
 
-    it "should respect the original if condition" do
+    it 'respects the original if condition' do
       view.upstream_if = false
       expect(helper.enabled_in_spotlight_view_type_configuration?(view)).to eq false
     end
 
-    it "should be true if there is no exhibit context" do
+    it 'is true if there is no exhibit context' do
       allow(helper).to receive(:current_exhibit).and_return(nil)
       expect(helper.enabled_in_spotlight_view_type_configuration?(view)).to eq true
     end
-    
-    it "should be true if we're in a page context" do
+
+    it "is true if we're in a page context" do
       allow(helper).to receive(:current_exhibit).and_return(nil)
       allow(controller).to receive(:is_a?).with(Spotlight::PagesController).and_return(true)
       expect(helper.enabled_in_spotlight_view_type_configuration?(view)).to eq true
     end
   end
-
 end

data/spec/helpers/spotlight/navbar_helper_spec.rb

@@ -1,20 +1,20 @@
 require 'spec_helper'
 
 module Spotlight
-  describe NavbarHelper, :type => :helper do
+  describe NavbarHelper, type: :helper do
     describe '#should_render_search_bar?' do
       before do
         allow(helper).to receive_messages(current_exhibit: nil)
         allow(helper).to receive_messages(exhibit_masthead?: true)
       end
-      it 'should return true when there is no exhibit context' do
+      it 'returns true when there is no exhibit context' do
         expect(helper.should_render_spotlight_search_bar?).to be_truthy
       end
-      it 'should return true if searchable' do
+      it 'returns true if searchable' do
         allow(helper).to receive_messages(current_exhibit: double(searchable?: true))
         expect(helper.should_render_spotlight_search_bar?).to be_truthy
       end
-      it 'should return false if currently under an "Exhibity" browse category' do
+      it 'returns false if currently under an "Exhibity" browse category' do
         allow(helper).to receive_messages(exhibit_masthead?: false)
         expect(helper.should_render_spotlight_search_bar?).to be_falsey
       end

data/spec/helpers/spotlight/pages_helper_spec.rb

@@ -1,77 +1,96 @@
 require 'spec_helper'
 
 module Spotlight
-  describe PagesHelper, :type => :helper do
+  describe PagesHelper, type: :helper do
     let(:blacklight_config) { Blacklight::Configuration.new { |config| config.show.title_field = :abc } }
-    let(:titled_document)   { ::SolrDocument.new( :abc => "value" ) }
-    let(:untitled_document) { ::SolrDocument.new( :id  => "1234"  ) }
+    let(:titled_document) { ::SolrDocument.new(abc: 'value') }
+    let(:untitled_document) { ::SolrDocument.new(id: '1234') }
     let!(:current_exhibit) { FactoryGirl.create(:exhibit) }
     let!(:home_page) { current_exhibit.home_page }
-    let!(:search) { FactoryGirl.create(:search, exhibit: current_exhibit, query_params: { "q" => "query" }, on_landing_page: true ) }
+    let!(:search) { FactoryGirl.create(:search, exhibit: current_exhibit, query_params: { 'q' => 'query' }, published: true) }
 
     before(:each) do
-      allow(helper).to receive_messages(:blacklight_config => blacklight_config)
+      allow(helper).to receive_messages(blacklight_config: blacklight_config)
     end
 
-    describe "has_title?" do
-      it "should return true if the title is not the same as the ID" do
-        expect(helper.has_title? titled_document).to be_truthy
+    describe 'available_index_fields' do
+      before do
+        blacklight_config.index.title_field = :title_field
+        blacklight_config.add_index_field 'x', label: 'X'
       end
-      it "should return false if the document heading returned is the same as the ID (indicating there is no title)" do
-        expect(helper.has_title? untitled_document).to be_falsey
+
+      it 'lists the configured index fields' do
+        expect(helper.available_index_fields).to include key: 'x', label: 'X'
+      end
+
+      it 'adds the title field if necessary' do
+        expect(helper.available_index_fields).to include key: :title_field, label: 'Title'
       end
     end
-    describe "disable_save_pages_button?" do
-      it "should return true if there are no pages and we are on the about pages page" do
-        expect(helper).to receive(:page_collection_name).and_return("about_pages")
+
+    describe 'disable_save_pages_button?' do
+      it 'returns true if there are no pages and we are on the about pages page' do
+        expect(helper).to receive(:page_collection_name).and_return('about_pages')
         assign(:pages, [])
         expect(helper.disable_save_pages_button?).to be_truthy
       end
-      it "should return false if there are about pages" do
-        expect(helper).to receive(:page_collection_name).and_return("about_pages")
+      it 'returns false if there are about pages' do
+        expect(helper).to receive(:page_collection_name).and_return('about_pages')
         assign(:pages, [{}])
         expect(helper.disable_save_pages_button?).to be_falsey
       end
-      it "should return false if on the feature pages page" do
-        expect(helper).to receive(:page_collection_name).and_return("feature_pages")
+      it 'returns false if on the feature pages page' do
+        expect(helper).to receive(:page_collection_name).and_return('feature_pages')
         assign(:pages, [])
         expect(helper.disable_save_pages_button?).to be_falsey
       end
     end
-    describe "get_search_widget_search_results" do
-      let(:good) { SirTrevorRails::Blocks::SearchResultsBlock.new({type: 'xyz', data: {'item' => { search.slug => { id: search.slug, display: "true" }}}}, home_page) }
-      let(:bad) { SirTrevorRails::Blocks::SearchResultsBlock.new({type: 'xyz', data: { 'item' => { 'garbage' => { id: 'missing', display: "true" }}}}, home_page) }
+    describe 'get_search_widget_search_results' do
+      let(:good) do
+        content = { type: 'xyz', data: { 'item' => { search.slug => { id: search.slug, display: 'true' } } } }
+        SirTrevorRails::Blocks::SearchResultsBlock.new(content, home_page)
+      end
+
+      let(:bad) do
+        content = { type: 'xyz', data: { 'item' => { 'garbage' => { id: 'missing', display: 'true' } } } }
+        SirTrevorRails::Blocks::SearchResultsBlock.new(content, home_page)
+      end
+
       let(:search_result) { [double('response'), double('documents')] }
-      it "should return the results for a given search browse category" do
-        expect(helper).to receive(:get_search_results).with({"q" => "query"}).and_return(search_result)
-        expect(helper.get_search_widget_search_results( good )).to eq search_result
+
+      it 'returns the results for a given search browse category' do
+        allow(helper).to receive(:search_params_logic).and_return([])
+        expect(helper).to receive(:search_results).with({ 'q' => 'query' }, []).and_return(search_result)
+        expect(helper.get_search_widget_search_results(good)).to eq search_result
       end
-      it "should return an empty array when requesting a search that doesn't exist" do
-        expect(helper.get_search_widget_search_results( bad )).to be_empty
+      it "returns an empty array when requesting a search that doesn't exist" do
+        expect(helper.get_search_widget_search_results(bad)).to be_empty
       end
     end
 
     describe 'nestable helpers' do
       describe 'nestable data attributes' do
-        it 'should return the appropriate attributes for feature pages' do
-          expect(helper.nestable_data_attributes("feature_pages")).to eq "data-max-depth='2' data-expand-btn-HTML='' data-collapse-btn-HTML=''"
+        it 'returns the appropriate attributes for feature pages' do
+          expect(helper.nestable_data_attributes('feature_pages')).to eq "data-max-depth='2' data-expand-btn-HTML='' data-collapse-btn-HTML=''"
         end
-        it 'should return the appropriate attributes for about pages' do
-          expect(helper.nestable_data_attributes("about_pages")).to eq "data-max-depth='1'"
+        it 'returns the appropriate attributes for about pages' do
+          expect(helper.nestable_data_attributes('about_pages')).to eq "data-max-depth='1'"
         end
-        it 'should return a blank string if the type is not valid' do
-          expect(helper.nestable_data_attributes("something_else")).to eq ""
+        it 'returns a blank string if the type is not valid' do
+          expect(helper.nestable_data_attributes('something_else')).to eq ''
         end
       end
       describe 'nestable data attributes hash' do
-        it 'should return the appropriate hash for feature pages' do
-          expect(helper.nestable_data_attributes_hash("feature_pages")).to eq({:"data-max-depth"=>"2", :"data-expand-btn-HTML"=>"", :"data-collapse-btn-HTML"=>""})
+        it 'returns the appropriate hash for feature pages' do
+          expect(helper.nestable_data_attributes_hash('feature_pages')).to eq "data-max-depth": '2',
+                                                                              "data-expand-btn-HTML": '',
+                                                                              "data-collapse-btn-HTML": ''
         end
-        it 'should return the appropriate hash for about pages' do
-          expect(helper.nestable_data_attributes_hash("about_pages")).to eq({:"data-max-depth"=>"1"})
+        it 'returns the appropriate hash for about pages' do
+          expect(helper.nestable_data_attributes_hash('about_pages')).to eq "data-max-depth": '1'
         end
-        it 'should return an empty hash if the type is not valid' do
-          expect(helper.nestable_data_attributes_hash("something_else")).to eq({})
+        it 'returns an empty hash if the type is not valid' do
+          expect(helper.nestable_data_attributes_hash('something_else')).to eq({})
         end
       end
     end