blacklight-spotlight 3.4.0 → 3.4.1

data/spec/controllers/spotlight/search_configurations_controller_spec.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::SearchConfigurationsController, type: :controller do
-  routes { Spotlight::Engine.routes }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  describe 'when the user is not authorized' do
-    before do
-      sign_in FactoryBot.create(:exhibit_visitor)
-    end
-
-    describe 'GET edit' do
-      it 'denies access' do
-        get :edit, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.root_path
-        expect(flash[:alert]).to be_present
-      end
-    end
-  end
-
-  describe 'when not logged in' do
-    describe 'PATCH update' do
-      it 'denies access' do
-        patch :update, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.new_user_session_path
-      end
-    end
-
-    describe 'GET edit' do
-      it 'denies access' do
-        get :edit, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.new_user_session_path
-      end
-    end
-  end
-
-  describe 'when signed in' do
-    let(:user) { FactoryBot.create(:exhibit_admin, exhibit: exhibit) }
-
-    before { sign_in user }
-
-    describe 'GET edit' do
-      it 'is successful' do
-        expect(controller).to receive(:add_breadcrumb).with('Home', exhibit)
-        expect(controller).to receive(:add_breadcrumb).with('Configuration', exhibit_dashboard_path(exhibit))
-        expect(controller).to receive(:add_breadcrumb).with('Search', edit_exhibit_search_configuration_path(exhibit))
-        get :edit, params: { exhibit_id: exhibit }
-        expect(response).to be_successful
-      end
-
-      it 'assigns the field metadata' do
-        get :edit, params: { exhibit_id: exhibit }
-        expect(assigns(:field_metadata)).to be_an_instance_of(Spotlight::FieldMetadata)
-        expect(assigns(:field_metadata).repository).to be_an_instance_of(controller.blacklight_config.repository_class)
-        expect(assigns(:field_metadata).blacklight_config).to eq controller.blacklight_config
-      end
-    end
-
-    describe 'PATCH update' do
-      it 'updates facet fields' do
-        patch :update, params: {
-          exhibit_id: exhibit,
-          blacklight_configuration: {
-            facet_fields: { 'genre_ssim' => { enabled: '1', label: 'Label' } }
-          }
-        }
-        expect(flash[:notice]).to eq 'The exhibit was successfully updated.'
-        expect(response).to redirect_to edit_exhibit_search_configuration_path(exhibit)
-        assigns[:exhibit].tap do |saved|
-          expect(saved.blacklight_configuration.facet_fields.keys).to eq ['genre_ssim']
-        end
-      end
-
-      it 'updates sort fields' do
-        patch :update, params: {
-          exhibit_id: exhibit,
-          blacklight_configuration: {
-            sort_fields: {
-              'relevance' => { 'enabled' => '1', 'label' => 'Relevance' },
-              'title' => { 'enabled' => '1', 'label' => 'Title' },
-              'type' => { 'enabled' => '1', 'label' => 'Type' },
-              'date' => { 'enabled' => '0', 'label' => 'Date' },
-              'source' => { 'enabled' => '0', 'label' => 'Source' },
-              'identifier' => { 'enabled' => '0', 'label' => 'Identifier' }
-            }
-          }
-        }
-        expect(flash[:notice]).to eq 'The exhibit was successfully updated.'
-        expect(response).to redirect_to edit_exhibit_search_configuration_path(exhibit)
-        assigns[:exhibit].tap do |saved|
-          expect(saved.blacklight_configuration.sort_fields).to eq(
-            'relevance' => { 'label' => 'Relevance', 'enabled' => true },
-            'title' => { 'label' => 'Title', 'enabled' => true },
-            'type' => { 'label' => 'Type', 'enabled' => true },
-            'date' => { 'label' => 'Date', 'enabled' => false },
-            'source' => { 'label' => 'Source', 'enabled' => false },
-            'identifier' => { 'label' => 'Identifier', 'enabled' => false }
-          )
-        end
-      end
-
-      it 'updates search fields' do
-        patch :update, params: {
-          exhibit_id: exhibit,
-          blacklight_configuration: {
-            search_fields: {
-              'all_fields' => { 'enabled' => '1' },
-              'title' => { 'enabled' => '0', 'label' => 'Title' },
-              'author' => { 'enabled' => '1', 'label' => 'Primary Author' }
-            }
-          }
-        }
-        expect(flash[:notice]).to eq 'The exhibit was successfully updated.'
-        expect(response).to redirect_to edit_exhibit_search_configuration_path(exhibit)
-        assigns[:exhibit].tap do |saved|
-          expect(saved.blacklight_configuration.search_fields).to eq(
-            'all_fields' => { 'label' => 'Everything', 'enabled' => true },
-            'title' => { 'label' => 'Title', 'enabled' => false },
-            'author' => { 'label' => 'Primary Author', 'enabled' => true }
-          )
-        end
-      end
-
-      it 'updates appearance fields' do
-        patch :update, params: {
-          exhibit_id: exhibit,
-          blacklight_configuration: {
-            document_index_view_types: { 'list' => '1', 'gallery' => '1', 'map' => '0' },
-            default_per_page: '50'
-          }
-        }
-        expect(flash[:notice]).to eq 'The exhibit was successfully updated.'
-        expect(response).to redirect_to edit_exhibit_search_configuration_path(exhibit)
-        assigns[:exhibit].tap do |saved|
-          expect(saved.blacklight_configuration.document_index_view_types).to eq %w[list gallery]
-          expect(saved.blacklight_configuration.default_per_page).to eq 50
-        end
-      end
-    end
-  end
-end

data/spec/controllers/spotlight/searches_controller_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::SearchesController, type: :controller do
-  routes { Spotlight::Engine.routes }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  before do
-    allow(Spotlight::DefaultThumbnailJob).to receive(:perform_later)
-  end
-
-  describe 'when the user is not authorized' do
-    before do
-      sign_in FactoryBot.create(:exhibit_visitor)
-    end
-
-    describe 'POST create' do
-      it 'denies access' do
-        post :create, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.root_path
-        expect(flash[:alert]).to be_present
-      end
-    end
-
-    describe 'GET index' do
-      it 'denies access' do
-        get :index, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.root_path
-        expect(flash[:alert]).to be_present
-      end
-    end
-  end
-
-  describe 'when the user is a curator' do
-    before do
-      sign_in FactoryBot.create(:exhibit_curator, exhibit: exhibit)
-    end
-
-    let(:search) { FactoryBot.create(:search, exhibit: exhibit) }
-
-    it 'creates a saved search' do
-      request.env['HTTP_REFERER'] = '/referring_url'
-      post :create, params: { 'search' => { 'title' => 'A bunch of maps' }, 'f' => { 'genre_ssim' => ['map'] }, exhibit_id: exhibit }
-      expect(response).to redirect_to '/referring_url'
-      expect(flash[:notice]).to eq 'The browse category was created.'
-      expect(assigns[:search].title).to eq 'A bunch of maps'
-      expect(assigns[:search].query_params).to eq('f' => { 'genre_ssim' => ['map'] })
-    end
-
-    describe 'GET index' do
-      let!(:search) { FactoryBot.create(:search, exhibit: exhibit) }
-      let(:group) { FactoryBot.create(:group, published: true, title: 'Good group', exhibit: exhibit, searches: [search]) }
-
-      it 'shows all the items' do
-        expect(controller).to receive(:add_breadcrumb).with('Home', exhibit)
-        expect(controller).to receive(:add_breadcrumb).with('Curation', exhibit_dashboard_path(exhibit))
-        expect(controller).to receive(:add_breadcrumb).with('Browse', exhibit_searches_path(exhibit))
-        get :index, params: { exhibit_id: search.exhibit_id }
-        expect(response).to be_successful
-        expect(assigns[:exhibit]).to eq search.exhibit
-        expect(assigns[:searches]).to include search
-      end
-
-      it 'assigns groups and group' do
-        get :index, params: { exhibit_id: search.exhibit_id }
-        expect(response).to be_successful
-        expect(assigns[:groups]).to eq [group]
-      end
-
-      it 'has a JSON response with published resources' do
-        search.published = true
-        search.save!
-
-        get :index, params: { exhibit_id: exhibit, format: 'json' }
-        expect(response).to be_successful
-        json = JSON.parse(response.body)
-        expect(json.last).to include('id' => search.id, 'title' => search.title)
-      end
-    end
-
-    describe 'GET autocomplete' do
-      let(:search) do
-        FactoryBot.create(:search, exhibit: exhibit, title: 'New Mexico Maps', query_params: { q: 'New Mexico' })
-      end
-
-      let(:search_fq) do
-        FactoryBot.create(:search, exhibit: exhibit, title: 'New Mexico Maps', query_params: { f: { subject_geographic_ssim: ['Pacific Ocean'] } })
-      end
-
-      it "shows all the items returned search's query_params" do
-        pending("A search defined by a query doesn't work with autocomplete correctly.")
-        get :autocomplete, params: { exhibit_id: exhibit, id: search, format: 'json' }
-        expect(response).to be_successful
-        docs = JSON.parse(response.body)['docs']
-        doc_ids = docs.map { |d| d['id'] }
-        expect(docs.length).to eq 2
-        expect(doc_ids).to include 'cz507zk0531'
-        expect(doc_ids).to include 'rz818vx8201'
-      end
-
-      it 'searches within the items returned in the query_params' do
-        get :autocomplete, params: { exhibit_id: exhibit, id: search_fq, q: 'California', format: 'json' }
-        expect(response).to be_successful
-        docs = JSON.parse(response.body)['docs']
-        expect(docs.length).to eq 1
-        expect(docs.first['id']).to eq 'sn161bw2027'
-        expect(docs.first['description']).to eq 'sn161bw2027'
-        expect(docs.first['title']).to match(/Pas-caart van Zuyd-Zee/)
-        expect(docs.first).to have_key('thumbnail')
-        expect(docs.first).to have_key('url')
-      end
-    end
-
-    describe 'GET edit' do
-      it 'shows edit page' do
-        get :edit, params: { id: search, exhibit_id: search.exhibit }
-        expect(response).to be_successful
-        expect(assigns[:search]).to eq search
-        expect(assigns[:exhibit]).to eq search.exhibit
-      end
-    end
-
-    describe 'PATCH update' do
-      it 'shows edit page' do
-        patch :update, params: {
-          id: search,
-          exhibit_id: search.exhibit,
-          search: {
-            title: 'Hey man',
-            long_description: 'long',
-            featured_image: 'http://lorempixel.com/64/64/',
-            masthead_attributes: { iiif_url: '' },
-            thumbnail_attributes: { iiif_url: '' }
-          }
-        }
-
-        expect(assigns[:search].title).to eq 'Hey man'
-        expect(response).to redirect_to exhibit_searches_path(search.exhibit)
-      end
-
-      it "renders edit if there's an error" do
-        expect_any_instance_of(Spotlight::Search).to receive(:update).and_return(false)
-        patch :update, params: {
-          id: search,
-          exhibit_id: search.exhibit,
-          search: {
-            title: 'Hey man',
-            long_description: 'long',
-            featured_image: 'http://lorempixel.com/64/64/'
-          }
-        }
-
-        expect(response).to be_successful
-        expect(response).to render_template 'edit'
-      end
-    end
-
-    describe 'DELETE destroy' do
-      let!(:search) { FactoryBot.create(:search, exhibit: exhibit) }
-
-      it 'removes it' do
-        expect do
-          delete :destroy, params: { id: search, exhibit_id: search.exhibit }
-        end.to change(Spotlight::Search, :count).by(-1)
-        expect(response).to redirect_to exhibit_searches_path(search.exhibit)
-        expect(flash[:alert]).to eq 'The browse category was deleted.'
-      end
-    end
-
-    describe 'POST update_all' do
-      let!(:search2) { FactoryBot.create(:search, exhibit: exhibit, published: true) }
-      let!(:search3) { FactoryBot.create(:search, exhibit: exhibit, published: true) }
-
-      before { request.env['HTTP_REFERER'] = '/whatever' }
-
-      it 'updates whether they are on the landing page' do
-        post :update_all, params: {
-          exhibit_id: exhibit,
-          exhibit: {
-            searches_attributes: [
-              { id: search.id, published: true, weight: '1' },
-              { id: search2.id, published: false, weight: '0' }
-            ]
-          }
-        }
-
-        expect(search.reload.published).to be_truthy
-        expect(search.weight).to eq 1
-        expect(search2.reload.published).to be_falsey
-        expect(search3.reload.published).to be_truthy # should remain untouched since it wasn't present
-        expect(response).to redirect_to end_with('/whatever')
-        expect(flash[:notice]).to eq 'Browse categories were successfully updated.'
-      end
-    end
-  end
-end

data/spec/controllers/spotlight/sites_controller_spec.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::SitesController, type: :controller do
-  routes { Spotlight::Engine.routes }
-
-  describe 'when user does not have access' do
-    before { sign_in FactoryBot.create(:exhibit_visitor) }
-
-    describe 'GET edit' do
-      it 'denies access' do
-        get :edit
-        expect(response).to redirect_to main_app.root_path
-      end
-    end
-  end
-
-  describe 'when user is an admin' do
-    let(:admin) { FactoryBot.create(:site_admin) }
-
-    before { sign_in admin }
-
-    describe 'GET edit' do
-      it 'allows access' do
-        get :edit
-        expect(response).to be_successful
-      end
-    end
-
-    describe 'GET edit_exhibits' do
-      it 'allows access' do
-        get :edit_exhibits
-        expect(response).to be_successful
-      end
-    end
-
-    describe 'PATCH update' do
-      let!(:exhibit_a) { FactoryBot.create(:exhibit) }
-      let!(:exhibit_b) { FactoryBot.create(:exhibit) }
-
-      it 'changes the exhibit order' do
-        patch :update, params: {
-          site: {
-            exhibits_attributes: [{ id: exhibit_a.id, weight: 5 }, { id: exhibit_b.id, weight: 2 }],
-            masthead_attributes: { display: 0 }
-          }
-        }
-
-        expect(response).to redirect_to(exhibits_path)
-
-        expect(Spotlight::Exhibit.ordered_by_weight.first).to eq exhibit_b
-        expect(exhibit_a.reload.weight).to eq 5
-      end
-    end
-
-    describe 'GET tags' do
-      let!(:exhibit_a) { FactoryBot.create(:exhibit, tag_list: 'a') }
-
-      it 'serializes the exhibit-level tags' do
-        get :tags, params: { format: 'json' }
-        expect(response).to be_successful
-        data = JSON.parse(response.body)
-
-        expect(data).to include 'a'
-      end
-    end
-  end
-end

data/spec/controllers/spotlight/solr_controller_spec.rb

@@ -1,116 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::SolrController, type: :controller do
-  routes { Spotlight::Engine.routes }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  describe 'when user does not have access' do
-    before { sign_in FactoryBot.create(:exhibit_visitor) }
-
-    describe 'POST update' do
-      it 'does not allow update' do
-        post :update, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.root_path
-      end
-    end
-  end
-
-  describe 'when user is an admin' do
-    let(:admin) { FactoryBot.create(:site_admin) }
-    let(:role) { admin.roles.first }
-    let(:connection) { instance_double(RSolr::Client) }
-    let(:repository) { instance_double(Blacklight::Solr::Repository, connection: connection) }
-    let!(:custom_field) { FactoryBot.create :custom_field, exhibit: exhibit, slug: 'custom_field' }
-
-    before { sign_in admin }
-
-    before do
-      allow(controller).to receive(:repository).and_return(repository)
-    end
-
-    describe 'POST update' do
-      it 'passes through the request data' do
-        doc = {}
-        expect(connection).to receive(:update) do |params|
-          doc = JSON.parse(params[:data], symbolize_names: true)
-        end
-
-        post_update_with_json_body(exhibit, a: 1)
-
-        expect(response).to be_successful
-        expect(doc.first).to include a: 1
-      end
-
-      context 'when the index is not writable' do
-        before do
-          allow(Spotlight::Engine.config).to receive_messages(writable_index: false)
-        end
-
-        it 'raises an error' do
-          post_update_with_json_body(exhibit, a: 1)
-
-          expect(response.code).to eq '409'
-        end
-      end
-
-      it 'enriches the request with exhibit solr data' do
-        doc = {}
-        expect(connection).to receive(:update) do |params|
-          doc = JSON.parse(params[:data], symbolize_names: true)
-        end
-
-        post_update_with_json_body(exhibit, a: 1)
-
-        expect(response).to be_successful
-        expect(doc.first).to include exhibit.solr_data
-      end
-
-      it 'enriches the request with sidecar data' do
-        doc = {}
-        expect(connection).to receive(:update) do |params|
-          doc = JSON.parse(params[:data], symbolize_names: true)
-        end
-
-        allow_any_instance_of(SolrDocument).to receive(:to_solr).and_return(b: 1)
-
-        post_update_with_json_body(exhibit, a: 1)
-
-        expect(response).to be_successful
-        expect(doc.first).to include b: 1
-      end
-
-      it 'creates sidecars for data that matches custom field slugs' do
-        doc = {}
-        expect(connection).to receive(:update) do |params|
-          doc = JSON.parse(params[:data], symbolize_names: true)
-        end
-
-        expect do
-          post_update_with_json_body(exhibit, a: 1, custom_field: 'abc')
-        end.to change(Spotlight::SolrDocumentSidecar, :count).by(1)
-
-        expect(response).to be_successful
-        expect(doc.first).to include a: 1
-      end
-
-      context 'with a file upload' do
-        let(:json) { fixture_file_upload(File.expand_path(File.join('..', 'spec', 'fixtures', 'json-upload-fixture.json'), Rails.root), 'application/json') }
-
-        it 'parses the uploaded file' do
-          doc = {}
-          expect(connection).to receive(:update) do |params|
-            doc = JSON.parse(params[:data], symbolize_names: true)
-          end
-          post :update, params: { resources_json_upload: { json: json }, exhibit_id: exhibit }
-
-          expect(response).to redirect_to exhibit_resources_path(exhibit)
-          expect(doc.first).to include a: 1
-        end
-      end
-    end
-  end
-
-  def post_update_with_json_body(exhibit, hash)
-    post :update, body: hash.to_json, params: { exhibit_id: exhibit }, as: :json
-  end
-end

data/spec/controllers/spotlight/tags_controller_spec.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-describe Spotlight::TagsController, type: :controller do
-  include ActiveJob::TestHelper
-
-  routes { Spotlight::Engine.routes }
-  let(:exhibit) { FactoryBot.create(:exhibit) }
-
-  before do
-    exhibit.tag(SolrDocument.new(id: 'x').sidecar(exhibit), with: 'paris, normandy', on: :tags)
-  end
-
-  describe 'when not signed in' do
-    describe 'GET index' do
-      it 'redirects to sign inl' do
-        get :index, params: { exhibit_id: exhibit }
-        expect(response).to redirect_to main_app.new_user_session_path
-      end
-    end
-  end
-
-  describe 'when signed in as a curator' do
-    before { sign_in FactoryBot.create(:exhibit_curator, exhibit: exhibit) }
-
-    describe 'GET index' do
-      it 'is successful' do
-        expect(controller).to receive(:add_breadcrumb).with('Home', exhibit)
-        expect(controller).to receive(:add_breadcrumb).with('Curation', exhibit_dashboard_path(exhibit))
-        expect(controller).to receive(:add_breadcrumb).with('Tags', exhibit_tags_path(exhibit))
-        get :index, params: { exhibit_id: exhibit }
-        expect(response).to be_successful
-        expect(assigns[:tags].length).to eq 2
-        expect(assigns[:tags].map(&:name)).to match_array %w[paris normandy]
-        expect(assigns[:exhibit]).to eq exhibit
-      end
-
-      it 'has a json serialization' do
-        get :index, params: { exhibit_id: exhibit, format: 'json' }
-        expect(response).to be_successful
-      end
-    end
-
-    describe 'DELETE destroy' do
-      let!(:tagging) { FactoryBot.create(:tagging, tagger: exhibit, taggable: exhibit) }
-
-      it 'is successful' do
-        expect do
-          perform_enqueued_jobs do
-            delete :destroy, params: { exhibit_id: exhibit, id: tagging.tag }
-          end
-        end.to change(ActsAsTaggableOn::Tagging, :count).by(-1)
-        expect(response).to redirect_to exhibit_tags_path(exhibit)
-      end
-    end
-  end
-end