blacklight-spotlight 0.4.1 → 0.5.0

data/spec/models/solr_document_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe SolrDocument, :type => :model do
+describe SolrDocument, type: :model do
   subject { ::SolrDocument.new(id: 'abcd123') }
-  its(:to_key) {should == ['abcd123']}
-  its(:persisted?) {should be_truthy}
+  its(:to_key) { should == ['abcd123'] }
+  its(:persisted?) { should be_truthy }
   before do
     allow(subject).to receive_messages(reindex: nil)
   end
@@ -11,119 +11,119 @@ describe SolrDocument, :type => :model do
   let(:exhibit) { FactoryGirl.create(:exhibit) }
   let(:exhibit_alt) { FactoryGirl.create(:exhibit) }
 
-  it "should have tags on the exhibit" do
+  it 'has tags on the exhibit' do
     expect(subject.tags_from(exhibit)).to be_empty
   end
 
-  it "should be able to add tags" do
-    expect {
-      exhibit.tag(subject, with: "paris, normandy", on: :tags)
-    }.to change { ActsAsTaggableOn::Tag.count}.by(2)
-    expect(subject.tags_from(exhibit)).to eq ['paris', 'normandy']
+  it 'is able to add tags' do
+    expect do
+      exhibit.tag(subject, with: 'paris, normandy', on: :tags)
+    end.to change { ActsAsTaggableOn::Tag.count }.by(2)
+    expect(subject.tags_from(exhibit)).to eq %w(paris normandy)
   end
 
-  it "should have find" do
-    expect(::SolrDocument.find('dq287tq6352')).to be_kind_of SolrDocument
+  it 'has find' do
+    expect(::SolrDocument.find('dq287tq6352')).to be_kind_of described_class
   end
 
-  it "should have ==" do
+  it 'has ==' do
     expect(::SolrDocument.find('dq287tq6352')).to eq ::SolrDocument.find('dq287tq6352')
   end
 
   describe 'GlobalID' do
     let(:doc_id) { 'dq287tq6352' }
-    it 'should respond to #to_global_id' do
+    it 'responds to #to_global_id' do
       expect(::SolrDocument.find(doc_id).to_global_id.to_s).to eq "gid://internal/SolrDocument/#{doc_id}"
     end
-    it 'should be able to locate SolrDocuments by their GlobalID' do
+    it 'is able to locate SolrDocuments by their GlobalID' do
       expect(GlobalID::Locator.locate(
         ::SolrDocument.find(doc_id).to_global_id
       )['id']).to eq doc_id
     end
   end
 
-  describe "#sidecar" do
-    it "should return a sidecar for adding exhibit-specific fields" do
+  describe '#sidecar' do
+    it 'returns a sidecar for adding exhibit-specific fields' do
       expect(subject.sidecar(exhibit)).to be_kind_of Spotlight::SolrDocumentSidecar
       expect(subject.sidecar(exhibit).exhibit).to eq exhibit
     end
-    
-    it "should keep distinct sidecars for each exhibit" do
+
+    it 'keeps distinct sidecars for each exhibit' do
       expect(subject.sidecar(exhibit).exhibit).to eq exhibit
       expect(subject.sidecar(exhibit_alt).exhibit).to eq exhibit_alt
     end
   end
 
-  describe "#update" do
-    it "should store sidecar data on the sidecar object" do
+  describe '#update' do
+    it 'stores sidecar data on the sidecar object' do
       mock_sidecar = double
       allow(subject).to receive_messages(sidecar: mock_sidecar)
       expect(mock_sidecar).to receive(:update).with(data: { 'a' => 1 })
-      subject.update exhibit, sidecar: { data: { 'a' => 1 }}
+      subject.update exhibit, sidecar: { data: { 'a' => 1 } }
     end
-    it "should store tags" do
-      subject.update exhibit, exhibit_tag_list: "paris, normandy"
-      expect(subject.tags_from(exhibit)).to eq ['paris', 'normandy']
+    it 'stores tags' do
+      subject.update exhibit, exhibit_tag_list: 'paris, normandy'
+      expect(subject.tags_from(exhibit)).to eq %w(paris normandy)
     end
   end
 
-  describe "#to_solr" do
+  describe '#to_solr' do
     before do
       Spotlight::SolrDocumentSidecar.create! document: subject, exhibit: exhibit,
-        data: {'a_tesim' => 1, 'b_tesim' => 2, 'c_tesim' => 3 }
+                                             data: { 'a_tesim' => 1, 'b_tesim' => 2, 'c_tesim' => 3 }
     end
 
-    it "should include the doc id" do
-      expect(subject.to_solr[:id]).to eq 'abcd123' 
+    it 'includes the doc id' do
+      expect(subject.to_solr[:id]).to eq 'abcd123'
     end
 
-    it "should include exhibit-specific tags" do
+    it 'includes exhibit-specific tags' do
       exhibit.tag(subject, with: 'paris', on: :tags)
 
       expect(subject.to_solr).to include :exhibit_1_tags_ssim
       expect(subject.to_solr[:exhibit_1_tags_ssim]).to include 'paris'
     end
 
-    it "should include placeholders for all exhibits' tags" do
+    it "includes placeholders for all exhibits' tags" do
       expect(subject.to_solr).to include :exhibit_1_tags_ssim
       expect(subject.to_solr[:exhibit_1_tags_ssim]).to eq nil
     end
 
-    it "should include sidecar fields" do
+    it 'includes sidecar fields' do
       expect(subject.to_solr).to include('a_tesim' => 1, 'b_tesim' => 2, 'c_tesim' => 3)
     end
   end
 
-  describe "#public?" do
-    it "should default to public" do
+  describe '#public?' do
+    it 'defaults to public' do
       expect(subject).to be_public exhibit
     end
   end
 
-  describe "#private?" do
-    it "should default to public" do
+  describe '#private?' do
+    it 'defaults to public' do
       expect(subject).not_to be_private exhibit
     end
   end
 
-  describe "#make_public!" do
-    it "should set the object to public" do
+  describe '#make_public!' do
+    it 'sets the object to public' do
       allow(subject).to receive(:reindex)
       subject.make_public! exhibit
       expect(subject).not_to be_private exhibit
     end
 
-    it "should augment existing sidecar data" do
+    it 'augments existing sidecar data' do
       allow(subject).to receive(:reindex)
 
-      subject.update exhibit, sidecar: { data: { a: 1}} 
+      subject.update exhibit, sidecar: { data: { a: 1 } }
       subject.make_public! exhibit
       expect(subject.sidecar(exhibit).data[:a]).to eq 1
     end
   end
 
-  describe "#make_private!" do
-    it "should set the object to private" do
+  describe '#make_private!' do
+    it 'sets the object to private' do
       allow(subject).to receive(:reindex)
       subject.make_private! exhibit
       expect(subject).to be_private exhibit
@@ -131,25 +131,24 @@ describe SolrDocument, :type => :model do
   end
 
   describe 'uploaded resources' do
-    let(:uploaded_resource) {
-      SolrDocument.new(
-        spotlight_resource_type_ssim: "spotlight/resources/uploads"
+    let(:uploaded_resource) do
+      described_class.new(
+        spotlight_resource_type_ssim: 'spotlight/resources/uploads'
       )
-    }
-    it 'should not include Spotlight::SolrDocument::UploadedResource when the correct fields are present' do
+    end
+    it 'does not include Spotlight::SolrDocument::UploadedResource when the correct fields are present' do
       expect(subject).to_not be_kind_of Spotlight::SolrDocument::UploadedResource
     end
-    it 'should include Spotlight::SolrDocument::UploadedResource when the correct fields are present' do
+    it 'includes Spotlight::SolrDocument::UploadedResource when the correct fields are present' do
       expect(uploaded_resource).to be_kind_of Spotlight::SolrDocument::UploadedResource
     end
     describe '#uploaded_resource?' do
-      it 'should return false if the correct fields are not present' do
+      it 'returns false if the correct fields are not present' do
         expect(subject).to_not be_uploaded_resource
       end
-      it 'should return true when the correct fields are present' do
+      it 'returns true when the correct fields are present' do
         expect(uploaded_resource).to be_uploaded_resource
       end
     end
   end
-
 end

data/spec/models/spotlight/ability_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 require 'cancan/matchers'
 
-describe Spotlight::Ability, :type => :model do
+describe Spotlight::Ability, type: :model do
   before do
-    allow_any_instance_of(Spotlight::Search).to receive(:default_featured_image)
+    allow_any_instance_of(Spotlight::Search).to receive(:set_default_featured_image)
   end
   let(:exhibit) { FactoryGirl.create(:exhibit) }
-  let(:search) {FactoryGirl.create(:published_search, exhibit: exhibit)}
-  let(:unpublished_search) {FactoryGirl.create(:search, exhibit: exhibit)}
-  let(:page) {FactoryGirl.create(:feature_page, exhibit: exhibit)}
+  let(:search) { FactoryGirl.create(:published_search, exhibit: exhibit) }
+  let(:unpublished_search) { FactoryGirl.create(:search, exhibit: exhibit) }
+  let(:page) { FactoryGirl.create(:feature_page, exhibit: exhibit) }
   subject { Ability.new(user) }
 
-  describe "a user with no roles" do
+  describe 'a user with no roles' do
     let(:user) { nil }
     it { is_expected.not_to be_able_to(:create, exhibit) }
     it { is_expected.to be_able_to(:read, exhibit) }
@@ -22,33 +22,31 @@ describe Spotlight::Ability, :type => :model do
     it { is_expected.not_to be_able_to(:tag, exhibit) }
   end
 
-  describe "a superadmin" do
+  describe 'a superadmin' do
     let(:user) { FactoryGirl.create(:site_admin) }
 
-    it { is_expected.to be_able_to(:create,  Spotlight::Exhibit) }
-
+    it { is_expected.to be_able_to(:create, Spotlight::Exhibit) }
   end
 
-  describe "a user with admin role" do
+  describe 'a user with admin role' do
     let(:user) { FactoryGirl.create(:exhibit_admin, exhibit: exhibit) }
     let(:role) { FactoryGirl.create(:role, exhibit: exhibit) }
 
     it { is_expected.to be_able_to(:update, exhibit) }
 
-    it { is_expected.to be_able_to(:index,   role) }
+    it { is_expected.to be_able_to(:index, role) }
     it { is_expected.to be_able_to(:destroy, role) }
-    it { is_expected.to be_able_to(:update,  role) }
-    it { is_expected.to be_able_to(:create,  Spotlight::Role) }
-    it { is_expected.not_to be_able_to(:create,  Spotlight::Exhibit) }
-    it { is_expected.to be_able_to(:import,  exhibit) }
-    it { is_expected.to be_able_to(:process_import,  exhibit) }
-    it { is_expected.to be_able_to(:destroy,  exhibit) }
+    it { is_expected.to be_able_to(:update, role) }
+    it { is_expected.to be_able_to(:create, Spotlight::Role) }
+    it { is_expected.not_to be_able_to(:create, Spotlight::Exhibit) }
+    it { is_expected.to be_able_to(:import, exhibit) }
+    it { is_expected.to be_able_to(:process_import, exhibit) }
+    it { is_expected.to be_able_to(:destroy, exhibit) }
 
     let(:blacklight_config) { role.exhibit.blacklight_configuration }
-    it { is_expected.to be_able_to(:edit, Spotlight::Appearance.new(blacklight_config)) }
   end
 
-  describe "a user with curate role" do
+  describe 'a user with curate role' do
     let(:user) { FactoryGirl.create(:exhibit_curator, exhibit: exhibit) }
 
     it { is_expected.not_to be_able_to(:update, exhibit) }
@@ -76,6 +74,5 @@ describe Spotlight::Ability, :type => :model do
 
     let(:role) { FactoryGirl.create(:role, exhibit: user.roles.first.exhibit) }
     let(:blacklight_config) { role.exhibit.blacklight_configuration }
-    it { is_expected.not_to be_able_to(:edit, Spotlight::Appearance.new(blacklight_config)) }
   end
 end

data/spec/models/spotlight/about_page_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Spotlight::AboutPage, :type => :model do
-  let(:page) { Spotlight::AboutPage.create! exhibit: FactoryGirl.create(:exhibit)  }
-  it {is_expected.not_to be_feature_page}
-  it {is_expected.to be_about_page}
-  it "should display the sidebar" do
+describe Spotlight::AboutPage, type: :model do
+  let(:page) { described_class.create! exhibit: FactoryGirl.create(:exhibit) }
+  it { is_expected.not_to be_feature_page }
+  it { is_expected.to be_about_page }
+  it 'displays the sidebar' do
     expect(page.display_sidebar?).to be_truthy
   end
-  it "should force the sidebar to display (we do not provide an interface for setting this to false)" do
+  it 'forces the sidebar to display (we do not provide an interface for setting this to false)' do
     expect(page.display_sidebar?).to be_truthy
     page.display_sidebar = false
     page.save

data/spec/models/spotlight/analytics/ga_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Spotlight::Analytics::Ga do
-  it "should not be enabled without configuration" do
+  it 'does not be enabled without configuration' do
     expect(described_class.enabled?).to be_falsey
   end
-end
+end

data/spec/models/spotlight/blacklight_configuration_spec.rb

@@ -1,46 +1,46 @@
 require 'spec_helper'
 
-describe Spotlight::BlacklightConfiguration, :type => :model do
-  subject { Spotlight::BlacklightConfiguration.new }
+describe Spotlight::BlacklightConfiguration, type: :model do
+  subject { described_class.new }
   let(:blacklight_config) { Blacklight::Configuration.new }
 
   before :each do
     blacklight_config.configure do |config|
-      config.add_sort_field 'relevance', sort: 'score desc, sort_title_ssi asc', :label => 'Relevance'
-      config.add_sort_field 'title', sort: 'sort_title_ssi asc', :label => 'Title'
-      config.add_sort_field 'type', sort: 'sort_type_ssi asc', :label => 'Type'
-      config.add_sort_field 'date', sort: 'sort_date_dtsi asc', :label => 'Date'
-      config.add_sort_field 'source', sort: 'sort_source_ssi asc', :label => 'Source'
-      config.add_sort_field 'identifier', sort: 'id asc', :label => 'Identifier'
+      config.add_sort_field 'relevance', sort: 'score desc, sort_title_ssi asc', label: 'Relevance'
+      config.add_sort_field 'title', sort: 'sort_title_ssi asc', label: 'Title'
+      config.add_sort_field 'type', sort: 'sort_type_ssi asc', label: 'Type'
+      config.add_sort_field 'date', sort: 'sort_date_dtsi asc', label: 'Date'
+      config.add_sort_field 'source', sort: 'sort_source_ssi asc', label: 'Source'
+      config.add_sort_field 'identifier', sort: 'id asc', label: 'Identifier'
     end
     allow(subject).to receive_messages default_blacklight_config: blacklight_config
     subject.exhibit = FactoryGirl.create(:exhibit)
   end
 
-  it "should touch the exhibit" do
+  it 'touches the exhibit' do
     expect(subject.exhibit).to receive :touch
     subject.save!
   end
 
-  it "should add a default thumbnail field" do
+  it 'adds a default thumbnail field' do
     expect(subject.blacklight_config.index.thumbnail_field).to eq Spotlight::Engine.config.thumbnail_field
   end
 
-  describe "facet fields" do
-    it "should have facet fields" do
+  describe 'facet fields' do
+    it 'has facet fields' do
       expect(subject.facet_fields).to be_empty
-      subject.facet_fields["title_facet"] = {}
-      subject.facet_fields["author_facet"] = {}
-      expect(subject.facet_fields.keys).to eq ['title_facet', 'author_facet']
+      subject.facet_fields['title_facet'] = {}
+      subject.facet_fields['author_facet'] = {}
+      expect(subject.facet_fields.keys).to eq %w(title_facet author_facet)
     end
 
-    it "should filter blank values" do
-      subject.facet_fields["title_facet"] = { something: "" }
+    it 'filters blank values' do
+      subject.facet_fields['title_facet'] = { something: '' }
       subject.valid?
-      expect(subject.facet_fields["title_facet"].keys).to_not include :something
+      expect(subject.facet_fields['title_facet'].keys).to_not include :something
     end
 
-    it "should filter the upstream blacklight config" do
+    it 'filters the upstream blacklight config' do
       subject.facet_fields['a'] = { show: true }
       subject.facet_fields['b'] = { show: false }
       subject.facet_fields['d'] = { show: true }
@@ -56,8 +56,7 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       expect(subject.blacklight_config.facet_fields['d']).to be_nil
     end
 
-    it "should order the fields by weight" do
-
+    it 'orders the fields by weight' do
       subject.facet_fields['a'] = { show: true, weight: 3 }
       subject.facet_fields['b'] = { show: true, weight: 5 }
       subject.facet_fields['c'] = { show: true, weight: 1 }
@@ -66,45 +65,43 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       blacklight_config.add_facet_field 'b'
       blacklight_config.add_facet_field 'c'
 
-      expect(subject.blacklight_config.facet_fields.keys).to eq ['c', 'a', 'b']
+      expect(subject.blacklight_config.facet_fields.keys).to eq %w(c a b)
     end
 
-    context "custom fields" do
-      it "should include any custom fields" do
+    context 'custom fields' do
+      it 'includes any custom fields' do
         allow(subject).to receive_messages(custom_facet_fields: { 'a' => double(if: nil, :if= => true, merge!: true, validate!: true, normalize!: true) })
         expect(subject.blacklight_config.facet_fields).to include('a')
       end
 
-      it "should default to not showing a custom field in the facets" do
+      it 'defaults to not showing a custom field in the facets' do
         allow(subject).to receive_messages(custom_facet_fields: { 'a' => Blacklight::Configuration::IndexField.new(field: 'a') })
         expect(subject.blacklight_config.facet_fields).to include('a')
         expect(subject.blacklight_config.facet_fields['a'].show).to be_falsey
       end
     end
 
-    context "exhibit fields" do
+    context 'exhibit fields' do
       before do
         # undo the stubbing we've used elsewhere..
         allow(subject).to receive(:default_blacklight_config).and_call_original
         allow(Spotlight::Engine).to receive_messages blacklight_config: blacklight_config
       end
-      it "should inject a tags facet" do
-        expect(subject.blacklight_config.facet_fields).to include "exhibit_tags"
+      it 'injects a tags facet' do
+        expect(subject.blacklight_config.facet_fields).to include 'exhibit_tags'
       end
     end
   end
 
-  describe "index fields" do
-
-    it "should have index fields" do
+  describe 'index fields' do
+    it 'has index fields' do
       expect(subject.index_fields).to be_empty
       subject.index_fields['title'] = {}
       subject.index_fields['author'] = {}
-      expect(subject.index_fields.keys).to eq ['title', 'author']
+      expect(subject.index_fields.keys).to eq %w(title author)
     end
 
-    it "should default to displaying all index fields if no exhibit-specific configuration is set " do
-
+    it 'defaults to displaying all index fields if no exhibit-specific configuration is set' do
       blacklight_config.add_index_field 'a'
       blacklight_config.add_index_field 'b'
       blacklight_config.add_index_field 'c'
@@ -117,18 +114,18 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       expect(subject.blacklight_config.index_fields['c'].list).to be_truthy
     end
 
-    it "should filter upstream fields that are always disabled" do
+    it 'filters upstream fields that are always disabled' do
       blacklight_config.add_index_field 'a', if: false
       expect(subject.blacklight_config.index_fields).not_to have_key 'a'
     end
 
-    it "should filter blank values" do
-      subject.index_fields['title'] = { something: "" }
+    it 'filters blank values' do
+      subject.index_fields['title'] = { something: '' }
       subject.valid?
-      expect(subject.index_fields["title"].keys).to_not include :something
+      expect(subject.index_fields['title'].keys).to_not include :something
     end
 
-    it "should filter the upstream blacklight config" do
+    it 'filters the upstream blacklight config' do
       subject.index_fields['a'] = { enabled: true, list: true }
       subject.index_fields['c'] = { enabled: false, list: false }
       subject.index_fields['d'] = { enabled: true, list: true }
@@ -144,20 +141,20 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       expect(subject.blacklight_config.index_fields['d']).to be_nil
     end
 
-    it "should include configured show fields, but disable them for index views" do
+    it 'includes configured show fields, but disable them for index views' do
       blacklight_config.add_show_field 'a'
       expect(subject.blacklight_config.index_fields).to have_key 'a'
       expect(subject.blacklight_config.index_fields['a'].enabled).to be_truthy
       expect(subject.blacklight_config.index_fields['a'].show).to be_truthy
       expect(subject.blacklight_config.index_fields['a'].list).to be_falsey
     end
-    
-    it "should filter show fields that are always disabled" do
+
+    it 'filters show fields that are always disabled' do
       blacklight_config.add_show_field 'a', if: false
       expect(subject.blacklight_config.index_fields).not_to have_key 'a'
     end
 
-    it "should include persisted configurations for show fields" do
+    it 'includes persisted configurations for show fields' do
       subject.index_fields['a'] = { enabled: true, list: true }
       blacklight_config.add_show_field 'a'
       expect(subject.blacklight_config.index_fields).to have_key 'a'
@@ -165,21 +162,21 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       expect(subject.blacklight_config.index_fields['a'].list).to be_truthy
     end
 
-    context "custom fields" do
-      it "should include any custom fields" do
+    context 'custom fields' do
+      it 'includes any custom fields' do
         subject.index_fields['a'] = { enabled: true, list: true }
         allow(subject).to receive_messages(custom_index_fields: { 'a' => double(if: nil, :if= => true, merge!: true, validate!: true, normalize!: true) })
         expect(subject.blacklight_config.index_fields).to include('a')
       end
 
-      it "should default to showing a custom field on the show view" do
+      it 'defaults to showing a custom field on the show view' do
         allow(subject).to receive_messages(custom_index_fields: { 'a' => Blacklight::Configuration::IndexField.new(field: 'a') })
         expect(subject.blacklight_config.index_fields).to include('a')
         expect(subject.blacklight_config.index_fields['a'].show).to be_truthy
         expect(subject.blacklight_config.index_fields['a'].enabled).to be_truthy
       end
 
-      it "should use explicit configuration to override custom field defaults" do
+      it 'uses explicit configuration to override custom field defaults' do
         subject.index_fields['a'] = { show: false }
         allow(subject).to receive_messages(custom_index_fields: { 'a' => Blacklight::Configuration::IndexField.new(field: 'a') })
         expect(subject.blacklight_config.index_fields).to include('a')
@@ -187,13 +184,13 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       end
     end
 
-    it "should prefer the label stored in index fields" do
+    it 'prefers the label stored in index fields' do
       subject.index_fields['a'] = { enabled: true, list: true, label: 'updated val' }
-      allow(subject).to receive_messages(custom_index_fields: { 'a' => Blacklight::Configuration::IndexField.new(:field => 'a', label: "Initial value") })
+      allow(subject).to receive_messages(custom_index_fields: { 'a' => Blacklight::Configuration::IndexField.new(field: 'a', label: 'Initial value') })
       expect(subject.blacklight_config.index_fields['a'].label).to eq 'updated val'
     end
 
-    it "should filter the upstream blacklight config with respect for view types" do
+    it 'filters the upstream blacklight config with respect for view types' do
       subject.index_fields['a'] = { enabled: true, list: true, gallery: false }
       subject.index_fields['b'] = { enabled: true, list: false, gallery: true }
       subject.index_fields['c'] = { enabled: false, list: true, gallery: false }
@@ -205,16 +202,16 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       blacklight_config.add_index_field 'c'
       blacklight_config.add_index_field 'd'
 
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.list }).to include('a')
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.gallery }).to include('b', 'd')
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.list }).to_not include('b', 'd')
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.gallery }).to_not include('a', 'c')
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.list }).to have(2).fields
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.list && x.enabled }).to have(1).fields
-      expect(subject.blacklight_config.index_fields.select { |k,x| x.gallery }).to have(2).fields
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.list }).to include('a')
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.gallery }).to include('b', 'd')
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.list }).to_not include('b', 'd')
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.gallery }).to_not include('a', 'c')
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.list }).to have(2).fields
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.list && x.enabled }).to have(1).fields
+      expect(subject.blacklight_config.index_fields.select { |_k, x| x.gallery }).to have(2).fields
     end
 
-    it "should filter the upstream blacklight config for show fields" do
+    it 'filters the upstream blacklight config for show fields' do
       subject.index_fields['a'] = { enabled: true, show: true }
       subject.index_fields['c'] = { enabled: false, show: false }
       subject.index_fields['d'] = { enabled: true, show: false }
@@ -223,12 +220,12 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       blacklight_config.add_index_field 'b'
       blacklight_config.add_index_field 'c'
 
-      expect(subject.blacklight_config.show_fields.select { |k,x| x.show && x.enabled }).to include('a')
-      expect(subject.blacklight_config.show_fields.select { |k,x| x.show && x.enabled }).to_not include('b', 'd')
-      expect(subject.blacklight_config.show_fields.select { |k,x| x.show && x.enabled }).to have(1).fields
+      expect(subject.blacklight_config.show_fields.select { |_k, x| x.show && x.enabled }).to include('a')
+      expect(subject.blacklight_config.show_fields.select { |_k, x| x.show && x.enabled }).to_not include('b', 'd')
+      expect(subject.blacklight_config.show_fields.select { |_k, x| x.show && x.enabled }).to have(1).fields
     end
 
-    it "should include any custom fields" do
+    it 'includes any custom fields' do
       subject.index_fields['a'] = { enabled: true, show: true }
 
       allow(subject).to receive_messages(custom_index_fields: { 'a' => double(if: nil, :if= => true, merge!: true, validate!: true, normalize!: true) })
@@ -236,8 +233,7 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       expect(subject.blacklight_config.show_fields).to include('a')
     end
 
-    it "should order the fields by weight" do
-
+    it 'orders the fields by weight' do
       subject.index_fields['a'] = { enabled: true, weight: 3, list: true }
       subject.index_fields['b'] = { enabled: true, weight: 5, list: true }
       subject.index_fields['c'] = { enabled: true, weight: 1, list: true }
@@ -246,11 +242,10 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       blacklight_config.add_index_field 'b'
       blacklight_config.add_index_field 'c'
 
-      expect(subject.blacklight_config.index_fields.keys).to eq ['c', 'a', 'b']
+      expect(subject.blacklight_config.index_fields.keys).to eq %w(c a b)
     end
 
-    it "should order the fields by weight" do
-
+    it 'orders the fields by weight' do
       subject.index_fields['a'] = { enabled: true, weight: 3, show: true }
       subject.index_fields['b'] = { enabled: true, weight: 5, show: true }
       subject.index_fields['c'] = { enabled: true, weight: 1, show: true }
@@ -259,43 +254,48 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       blacklight_config.add_index_field 'b'
       blacklight_config.add_index_field 'c'
 
-      expect(subject.blacklight_config.show_fields.keys).to eq ['c', 'a', 'b']
+      expect(subject.blacklight_config.show_fields.keys).to eq %w(c a b)
     end
   end
 
-  describe "a newly created instance" do
+  describe 'a newly created instance' do
     before do
       subject.save!
     end
-    describe "should have default values" do
-      its(:sort_fields) { should eq({
-          "identifier" => {:show=>true},
-          "relevance" => {:show=>true},
-          "date" => {:show=>true},
-          "source" => {:show=>true},
-          "title" => {:show=>true},
-          "type" => {:show=>true}
-        })}
+    describe 'should have default values' do
+      its(:sort_fields) do
+        should eq('identifier' => { enabled: true },
+                  'relevance' => { enabled: true },
+                  'date' => { enabled: true },
+                  'source' => { enabled: true },
+                  'title' => { enabled: true },
+                  'type' => { enabled: true })
+      end
+      its(:search_fields) do
+        should eq('all_fields' => { enabled: true },
+                  'title' => { enabled: true },
+                  'author' => { enabled: true })
+      end
       its(:default_per_page) { should eq 10 }
-      its(:document_index_view_types) { should match_array ::CatalogController.blacklight_config.view.keys.map { |x| x.to_s } }
+      its(:document_index_view_types) { should match_array ::CatalogController.blacklight_config.view.keys.map(&:to_s) }
     end
   end
 
-  describe "sort fields" do
-    it "should have sort fields" do
+  describe 'sort fields' do
+    it 'has sort fields' do
       expect(subject.sort_fields).to be_empty
       subject.sort_fields['title'] = {}
       subject.sort_fields['author'] = {}
-      expect(subject.sort_fields.keys).to eq ['title', 'author']
+      expect(subject.sort_fields.keys).to eq %w(title author)
     end
 
-    it "should filter blank values" do
-      subject.sort_fields['title'] = { something: "" }
+    it 'filters blank values' do
+      subject.sort_fields['title'] = { something: '' }
       subject.valid?
       expect(subject.sort_fields['title'].keys).to_not include :something
     end
 
-    it "should filter the upstream blacklight config" do
+    it 'filters the upstream blacklight config' do
       subject.sort_fields['a'] = { enabled: true }
       subject.sort_fields['c'] = { enabled: true }
       subject.sort_fields['d'] = { enabled: true }
@@ -304,118 +304,145 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
       blacklight_config.add_sort_field 'b'
       blacklight_config.add_sort_field 'c'
 
-      expect(subject.blacklight_config.sort_fields.select { |k,v| v.enabled == true}).to include('a', 'c')
-      expect(subject.blacklight_config.sort_fields.select { |k,v| v.enabled == true}).not_to include('b', 'd')
+      expect(subject.blacklight_config.sort_fields.select { |_k, v| v.enabled == true }).to include('a', 'c')
+      expect(subject.blacklight_config.sort_fields.select { |_k, v| v.enabled == true }).not_to include('b', 'd')
+    end
+  end
+
+  describe 'search fields' do
+    it 'has search fields' do
+      expect(subject.search_fields).to be_empty
+      subject.search_fields['title'] = {}
+      subject.search_fields['author'] = {}
+      expect(subject.search_fields.keys).to eq %w(title author)
+    end
+
+    it 'filters blank values' do
+      subject.search_fields['title'] = { something: '' }
+      subject.valid?
+      expect(subject.search_fields['title'].keys).to_not include :something
+    end
+
+    it 'filters the upstream blacklight config' do
+      subject.search_fields['a'] = { enabled: true }
+      subject.search_fields['c'] = { enabled: true }
+      subject.search_fields['d'] = { enabled: true }
+
+      blacklight_config.add_search_field 'a'
+      blacklight_config.add_search_field 'b'
+      blacklight_config.add_search_field 'c'
+
+      expect(subject.blacklight_config.search_fields.select { |_k, v| v.enabled == true }).to include('a', 'c')
+      expect(subject.blacklight_config.search_fields.select { |_k, v| v.enabled == true }).not_to include('b', 'd')
     end
   end
 
-  describe "per page" do
-    it "should have per page configuration" do
+  describe 'per page' do
+    it 'has per page configuration' do
       expect(subject.per_page).to be_empty
       subject.per_page << 10 << 50
       expect(subject.per_page).to eq [10, 50]
     end
 
-    it "should filter blank values" do
-      subject.per_page << ""
+    it 'filters blank values' do
+      subject.per_page << ''
       subject.valid?
-      expect(subject.per_page).to_not include ""
+      expect(subject.per_page).to_not include ''
     end
 
-    it "should filter the upstream blacklight config" do
+    it 'filters the upstream blacklight config' do
       subject.per_page = [10, 50, 1000]
       blacklight_config.per_page = [1, 10, 50, 100]
 
       expect(subject.blacklight_config.per_page).to eq [10, 50]
     end
-    
-    it "should prepend the default per page" do
+
+    it 'prepends the default per page' do
       blacklight_config.per_page = [1, 10, 50, 100]
       subject.default_per_page = 50
       expect(subject.blacklight_config.per_page.first).to eq 50
     end
   end
 
-  describe "document_index_view_types" do
-
-    it "should have index view configuration" do
+  describe 'document_index_view_types' do
+    it 'has index view configuration' do
       expect(subject.document_index_view_types).to be_empty
       subject.document_index_view_types << 'list' << 'gallery'
-      expect(subject.document_index_view_types).to eq ['list', 'gallery']
+      expect(subject.document_index_view_types).to eq %w(list gallery)
     end
 
-    it "should filter blank values" do
-      subject.document_index_view_types << ""
+    it 'filters blank values' do
+      subject.document_index_view_types << ''
       subject.valid?
-      expect(subject.document_index_view_types).to_not include ""
+      expect(subject.document_index_view_types).to_not include ''
     end
 
-    it "should filter the upstream blacklight config" do
-      subject.document_index_view_types = ['list', 'gallery', 'unknown']
+    it 'filters the upstream blacklight config' do
+      subject.document_index_view_types = %w(list gallery unknown)
       blacklight_config.view.list
       blacklight_config.view.gallery
       blacklight_config.view.something
 
       expect(subject.blacklight_config.view.keys).to include :list, :gallery, :something
-      expect(subject.blacklight_config.view.all? { |k,v| v.key == k and v.if == :enabled_in_spotlight_view_type_configuration? }).to be_truthy
+      expect(subject.blacklight_config.view.all? { |k, v| v.key == k && v.if == :enabled_in_spotlight_view_type_configuration? }).to be_truthy
     end
 
-    it "should pass through the blacklight configuration when not set" do
+    it 'passes through the blacklight configuration when not set' do
       blacklight_config.view.list
       blacklight_config.view.gallery
       blacklight_config.view.something
-      expect(subject.blacklight_config.view.keys).to include *blacklight_config.view.keys
+      expect(subject.blacklight_config.view.keys).to include(*blacklight_config.view.keys)
     end
   end
 
-  describe "default_solr_params" do
-    it "should have default solr params configuration" do
+  describe 'default_solr_params' do
+    it 'has default solr params configuration' do
       expect(subject.default_solr_params).to be_empty
       subject.default_solr_params[:qt] = 'custom_request_handler'
       expect(subject.default_solr_params[:qt]).to eq 'custom_request_handler'
     end
 
-    it "should merge with the blacklight config" do
-      blacklight_config.default_solr_params = { :qt => 'xyz', :rows => 10 }
+    it 'merges with the blacklight config' do
+      blacklight_config.default_solr_params = { qt: 'xyz', rows: 10 }
       subject.default_solr_params[:qt] = 'abc'
       expect(subject.blacklight_config.default_solr_params).to include(:qt, :rows)
       expect(subject.blacklight_config.default_solr_params[:qt]).to eq 'abc'
     end
   end
 
-  describe "show" do
-    it "should have show view configuration" do
+  describe 'show' do
+    it 'has show view configuration' do
       expect(subject.show).to be_empty
       subject.show[:key] = 'some value'
       expect(subject.show[:key]).to eq 'some value'
     end
 
-    it "should merge with the blacklight config" do
+    it 'merges with the blacklight config' do
       blacklight_config.show.title_field = 'xyz'
       subject.show[:title_field] = 'abc'
       expect(subject.blacklight_config.show.title_field).to eq 'abc'
     end
   end
 
-  describe "index" do
-    it "should have index view configuration" do
+  describe 'index' do
+    it 'has index view configuration' do
       expect(subject.index).to be_empty
       subject.index[:key] = 'some value'
       expect(subject.index[:key]).to eq 'some value'
     end
 
-    it "should merge with the blacklight config" do
+    it 'merges with the blacklight config' do
       blacklight_config.index.title_field = 'xyz'
       subject.index[:title_field] = 'abc'
       expect(subject.blacklight_config.index.title_field).to eq 'abc'
     end
   end
 
-  describe "#custom_index_fields" do
-    it "should convert exhibit-specific fields to Blacklight configurations" do
+  describe '#custom_index_fields' do
+    it 'converts exhibit-specific fields to Blacklight configurations' do
       allow(subject).to receive_messages(exhibit: double(custom_fields: [
-        stub_model(Spotlight::CustomField, field: "abc", configuration: { a: 1}),
-        stub_model(Spotlight::CustomField, field: "xyz", configuration: { x: 2})
+        stub_model(Spotlight::CustomField, field: 'abc', configuration: { a: 1 }),
+        stub_model(Spotlight::CustomField, field: 'xyz', configuration: { x: 2 })
       ]))
 
       expect(subject.custom_index_fields).to include 'abc', 'xyz'
@@ -424,36 +451,72 @@ describe Spotlight::BlacklightConfiguration, :type => :model do
     end
   end
 
-  describe "autocomplete configuration" do
+  describe 'autocomplete configuration' do
     before do
       # undo the stubbing we've used elsewhere..
       allow(subject).to receive(:default_blacklight_config).and_call_original
-      blacklight_config.show.title_field = "x"
+      blacklight_config.show.title_field = 'x'
       allow(Spotlight::Engine).to receive_messages blacklight_config: blacklight_config.deep_copy
     end
 
-    context "with the default search field" do
+    context 'with the default search field' do
       let(:search_field) do
         subject.blacklight_config.search_fields[Spotlight::Engine.config.autocomplete_search_field]
       end
 
-      it "should be hidden from the search field selector" do
+      it 'is hidden from the search field selector' do
         expect(search_field.if).to eq false
       end
 
-      it "should use the engine's autocomplete parameters" do
+      it "uses the engine's autocomplete parameters" do
         expect(search_field.solr_parameters).to include Spotlight::Engine.config.default_autocomplete_params
       end
 
-      it "should include the relevant fields" do
-        Spotlight::Engine.blacklight_config.show.title_field = "some_field"
+      it 'includes the relevant fields' do
+        Spotlight::Engine.blacklight_config.show.title_field = 'some_field'
         expect(search_field.solr_parameters).to have_key :fl
-        expect(search_field.solr_parameters[:fl]).to include "id"
-        expect(search_field.solr_parameters[:fl]).to include "some_field"
-        expect(search_field.solr_parameters[:fl]).to include "full_image_url_ssm"
-        expect(search_field.solr_parameters[:fl]).to include "thumbnail_url_ssm"
-        expect(search_field.solr_parameters[:fl]).to include "thumbnail_square_url_ssm"
+        expect(search_field.solr_parameters[:fl]).to include 'id'
+        expect(search_field.solr_parameters[:fl]).to include 'some_field'
+        expect(search_field.solr_parameters[:fl]).to include 'full_image_url_ssm'
+        expect(search_field.solr_parameters[:fl]).to include 'thumbnail_url_ssm'
+        expect(search_field.solr_parameters[:fl]).to include 'thumbnail_square_url_ssm'
       end
     end
   end
+
+  describe '#document_index_view_types' do
+    it 'passes arrays through' do
+      array = [1, 2, 3]
+      subject.document_index_view_types = array
+      expect(subject.document_index_view_types).to match_array array
+    end
+
+    it 'is simplified from a hash to an array' do
+      checkboxes_from_form = { 'list' => '1', 'gallery' => '1', 'map' => '0' }
+      subject.document_index_view_types = checkboxes_from_form
+      expect(subject.document_index_view_types).to match_array %w(list gallery)
+    end
+  end
+
+  describe '#document_index_view_types_selected_hash' do
+    before do
+      subject.default_blacklight_config.view.list
+      subject.default_blacklight_config.view.gallery
+      subject.default_blacklight_config.view.map
+      subject.default_blacklight_config.view.rss.if = false
+      subject.document_index_view_types = %w(list gallery rss)
+    end
+
+    it 'includes selected view types as the value true' do
+      expect(subject.document_index_view_types_selected_hash.to_h).to include list: true, gallery: true
+    end
+
+    it 'disabled view types are not included' do
+      expect(subject.document_index_view_types_selected_hash.to_h).not_to include :map
+    end
+
+    it 'excludes view types disabled by configuration (not by curator settings)' do
+      expect(subject.document_index_view_types_selected_hash.to_h).not_to include :rss
+    end
+  end
 end