blacklight_oai_provider 6.1.1 → 7.0.2

data/solr/conf/solrconfig.xml

@@ -32,8 +32,6 @@
   
   <lib dir="${solr.install.dir:../../../..}/contrib/analysis-extras/lib" />
   <lib dir="${solr.install.dir:../../../..}/contrib/analysis-extras/lucene-libs" />
-  <lib dir="${solr.install.dir:../../../..}/contrib/extraction/lib" regex=".*\.jar" />
-  <lib dir="${solr.install.dir:../../../..}/dist/" regex="solr-cell-\d.*\.jar" />
 
   <directoryFactory name="DirectoryFactory" 
                     class="${solr.directoryFactory:solr.NRTCachingDirectoryFactory}">
@@ -47,7 +45,7 @@
   <dataDir>${solr.blacklight-core.data.dir:}</dataDir>
   
   <requestDispatcher handleSelect="true" >
-    <requestParsers enableRemoteStreaming="false" multipartUploadLimitInKB="2048000" />
+    <requestParsers enableRemoteStreaming="false" multipartUploadLimitInKB="2048" />
   </requestDispatcher>
   
   <requestHandler name="/analysis/field" startup="lazy" class="solr.FieldAnalysisRequestHandler" />
@@ -57,21 +55,6 @@
     <defaultQuery>*:*</defaultQuery>
   </admin>
 
-  <updateHandler class="solr.DirectUpdateHandler2">
-    <updateLog>
-      <str name="dir">${solr.ulog.dir:}</str>
-    </updateLog>
-
-    <autoCommit>
-      <maxTime>${solr.autoCommit.maxTime:15000}</maxTime>
-      <openSearcher>false</openSearcher>
-    </autoCommit>
-
-    <autoSoftCommit>
-      <maxTime>${solr.autoSoftCommit.maxTime:-1}</maxTime>
-    </autoSoftCommit>
-  </updateHandler>
-
   <!-- SearchHandler
 
        http://wiki.apache.org/solr/SearchHandler
@@ -86,54 +69,161 @@
          will be overridden by parameters in the request
       -->
      <lst name="defaults">
-       <str name="defType">edismax</str>
+       <str name="defType">dismax</str>
        <str name="echoParams">explicit</str>
+       <int name="rows">10</int>
+
        <str name="q.alt">*:*</str>
        <str name="mm">2&lt;-1 5&lt;-2 6&lt;90%</str>
-       <int name="qs">1</int>
-       <int name="ps">2</int>
-       <float name="tie">0.01</float>
+
        <!-- this qf and pf are used by default, if not otherwise specified by
             client. The default blacklight_config will use these for the
-            "keywords" search. See the author_qf/author_pf, title_qf, etc
+            "keywords" search. See the author_qf/author_pf, title_qf, etc 
             below, which the default blacklight_config will specify for
             those searches. You may also be interested in:
             http://wiki.apache.org/solr/LocalParams
        -->
-        <str name="qf">
-          id
-          title_tsim
-          author_tsim
-          subject_ssim
-        </str>
-        <str name="pf">
-          all_text_timv^10
-        </str>
 
+       <str name="qf">
+         title_unstem_search^100000
+         subtitle_unstem_search^50000
+         title_t^25000
+         subtitle_t^10000
+         title_addl_unstem_search^5000
+         title_addl_t^2500
+         title_added_entry_unstem_search^1500
+         title_added_entry_t^1250
+         subject_topic_unstem_search^1000
+         subject_unstem_search^750
+         subject_topic_facet^625
+         subject_t^500
+         author_unstem_search^250
+         author_addl_unstem_search^250
+         author_t^100
+         author_addl_t^50
+         subject_addl_unstem_search^250
+         subject_addl_t^50
+         title_series_unstem_search^25
+         title_series_t^10
+         isbn_t
+         text
+       </str>
+       <str name="pf">
+         title_unstem_search^1000000
+         subtitle_unstem_search^500000
+         title_t^250000
+         subtitle_t^100000
+         title_addl_unstem_search^50000
+         title_addl_t^25000
+         title_added_entry_unstem_search^15000
+         title_added_entry_t^12500
+         subject_topic_unstem_search^10000
+         subject_unstem_search^7500
+         subject_topic_facet^6250
+         subject_t^5000
+         author_unstem_search^2500
+         author_addl_unstem_search^2500
+         author_t^1000
+         author_addl_t^500
+         subject_addl_unstem_search^2500
+         subject_addl_t^500
+         title_series_unstem_search^250
+         title_series_t^100
+         text^10
+       </str>
        <str name="author_qf">
-          author_tsim
+         author_unstem_search^200
+         author_addl_unstem_search^50
+         author_t^20
+         author_addl_t
        </str>
        <str name="author_pf">
+         author_unstem_search^2000
+         author_addl_unstem_search^500
+         author_t^200
+         author_addl_t^10
        </str>
        <str name="title_qf">
-          title_tsim
+         title_unstem_search^50000
+         subtitle_unstem_search^25000
+         title_addl_unstem_search^10000
+         title_t^5000
+         subtitle_t^2500
+         title_addl_t^100
+         title_added_entry_unstem_search^50
+         title_added_entry_t^10
+         title_series_unstem_search^5
+         title_series_t
        </str>
        <str name="title_pf">
+         title_unstem_search^500000
+         subtitle_unstem_search^250000
+         title_addl_unstem_search^100000
+         title_t^50000
+         subtitle_t^25000
+         title_addl_t^1000
+         title_added_entry_unstem_search^500
+         title_added_entry_t^100
+         title_series_t^50
+         title_series_unstem_search^10
        </str>
        <str name="subject_qf">
-          subject_ssim
+         subject_topic_unstem_search^200
+         subject_unstem_search^125
+         subject_topic_facet^100
+         subject_t^50
+         subject_addl_unstem_search^10
+         subject_addl_t
        </str>
        <str name="subject_pf">
+         subject_topic_unstem_search^2000
+         subject_unstem_search^1250
+         subject_t^1000
+         subject_topic_facet^500
+         subject_addl_unstem_search^100
+         subject_addl_t^10
        </str>
+       
+       <int name="ps">3</int>
+       <float name="tie">0.01</float>
 
        <str name="fl">
-         *,
-         score
+         id, 
+         score,
+         author_display,
+         author_vern_display, 
+         format, 
+         isbn_t, 
+         language_facet, 
+         lc_callnum_display,
+         material_type_display, 
+         published_display,
+         published_vern_display,
+         pub_date,
+         title_display,
+         title_vern_display,
+         subject_topic_facet,
+         subject_geo_facet,
+         subject_era_facet,
+         subtitle_display,
+         subtitle_vern_display,
+         url_fulltext_display,
+         url_suppl_display,
+         marc_display,
        </str>
 
        <str name="facet">true</str>
        <str name="facet.mincount">1</str>
-
+       <str name="facet.field">format</str>
+       <str name="facet.field">lc_1letter_facet</str>
+       <str name="facet.field">lc_alpha_facet</str>
+       <str name="facet.field">lc_b4cutter_facet</str>
+       <str name="facet.field">language_facet</str>
+       <str name="facet.field">pub_date</str>
+       <str name="facet.field">subject_era_facet</str>
+       <str name="facet.field">subject_geo_facet</str>
+       <str name="facet.field">subject_topic_facet</str>
+       
        <str name="spellcheck">true</str>
        <str name="spellcheck.dictionary">default</str>
        <str name="spellcheck.onlyMorePopular">true</str>
@@ -142,9 +232,62 @@
        <str name="spellcheck.count">5</str>
 
      </lst>
+    <!-- In addition to defaults, "appends" params can be specified
+         to identify values which should be appended to the list of
+         multi-val params from the query (or the existing "defaults").
+      -->
+    <!-- In this example, the param "fq=instock:true" would be appended to
+         any query time fq params the user may specify, as a mechanism for
+         partitioning the index, independent of any user selected filtering
+         that may also be desired (perhaps as a result of faceted searching).
+
+         NOTE: there is *absolutely* nothing a client can do to prevent these
+         "appends" values from being used, so don't use this mechanism
+         unless you are sure you always want it.
+      -->
+    <!--
+       <lst name="appends">
+         <str name="fq">inStock:true</str>
+       </lst>
+      -->
+    <!-- "invariants" are a way of letting the Solr maintainer lock down
+         the options available to Solr clients.  Any params values
+         specified here are used regardless of what values may be specified
+         in either the query, the "defaults", or the "appends" params.
+
+         In this example, the facet.field and facet.query params would
+         be fixed, limiting the facets clients can use.  Faceting is
+         not turned on by default - but if the client does specify
+         facet=true in the request, these are the only facets they
+         will be able to see counts for; regardless of what other
+         facet.field or facet.query params they may specify.
+
+         NOTE: there is *absolutely* nothing a client can do to prevent these
+         "invariants" values from being used, so don't use this mechanism
+         unless you are sure you always want it.
+      -->
+    <!--
+       <lst name="invariants">
+         <str name="facet.field">cat</str>
+         <str name="facet.field">manu_exact</str>
+         <str name="facet.query">price:[* TO 500]</str>
+         <str name="facet.query">price:[500 TO *]</str>
+       </lst>
+      -->
+    <!-- If the default list of SearchComponents is not desired, that
+         list can either be overridden completely, or components can be
+         prepended or appended to the default list.  (see below)
+      -->
+    <!--
+       <arr name="components">
+         <str>nameOfCustomComponent1</str>
+         <str>nameOfCustomComponent2</str>
+       </arr>
+      -->
     <arr name="last-components">
       <str>spellcheck</str>
     </arr>
+      
   </requestHandler>
 
 <!-- Spell Check
@@ -233,8 +376,6 @@
       -->
   </searchComponent>
 
-<!-- suggest searchComponent and requestHandler disabled by default due to performance penalties -->
-<!--
   <searchComponent name="suggest" class="solr.SuggestComponent">
     <lst name="suggester">
       <str name="name">mySuggester</str>
@@ -255,20 +396,6 @@
       <str>suggest</str>
     </arr>
   </requestHandler>
--->
- 
-  <requestHandler name="/update/extract" class="org.apache.solr.handler.extraction.ExtractingRequestHandler">
-    <lst name="defaults">
-      <str name="fmap.Last-Modified">last_modified</str>
-      <str name="uprefix">ignored_</str>
-    </lst>
-    <!--Optional.  Specify a path to a tika configuration file. See the Tika docs for details.-->
-    <!-- <str name="tika.config">/my/path/to/tika.config</str> -->
-    <!-- Optional. Specify one or more date formats to parse. See DateUtil.DEFAULT_DATE_FORMATS
-         for default date formats -->
-    <!-- <lst name="date.formats"> -->
-    <!--   <str>yyyy&#45;MM&#45;dd</str> -->
-    <!-- </lst> -->
-  </requestHandler>
+
 </config>
 

data/spec/controllers/catalog_controller_spec.rb

@@ -19,7 +19,7 @@ describe CatalogController do
     it 'returns correct provider configuration' do
       expect(controller.oai_config).to include(
         provider: {
-          repository_name: "Test Repository",
+          repository_name: "Catalog Repository",
           repository_url: "http://localhost/catalog/oai",
           record_prefix: "oai:test",
           admin_email: "root@localhost",

data/spec/integration/blacklight_oai_provider/solr_document_wrapper_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+RSpec.describe BlacklightOaiProvider::SolrDocumentWrapper do
+  subject(:wrapper) { described_class.new(controller, options) }
+
+  let(:options) { {} }
+  let(:controller_class) { CatalogController }
+  let(:controller) { controller_class.new }
+
+  before do
+    allow(controller).to receive(:params).and_return({})
+  end
+
+  describe '#earliest' do
+    it 'returns the earliest timestamp of all the records' do
+      expect(wrapper.earliest).to eq Time.parse('2014-02-03 18:42:53.056000000 +0000').utc
+    end
+  end
+
+  describe '#latest' do
+    it 'returns the latest timestamp of all the records' do
+      expect(wrapper.latest).to eq Time.parse('2015-02-03 18:42:53.056000000 +0000').utc
+    end
+  end
+
+  describe '#find' do
+    context 'when selector is :all' do
+      it 'returns a limited list of all records' do
+        expect(wrapper.find(:all)).to be_a OAI::Provider::PartialResult
+        expect(wrapper.find(:all).records.size).to be 15
+      end
+    end
+
+    context 'when selector is an individual record' do
+      let(:search_builder_class) do
+        Class.new(Blacklight::SearchBuilder) do
+          include Blacklight::Solr::SearchBuilderBehavior
+          self.default_processor_chain += [:only_visible]
+
+          def only_visible(solr_parameters)
+            solr_parameters[:fq] ||= []
+            solr_parameters[:fq] << 'visibility_si:"open"'
+          end
+        end
+      end
+      let(:controller_class) do
+        stub_const 'VisibilitySearchBuilder', search_builder_class
+        Class.new(CatalogController) do
+          blacklight_config.configure do |config|
+            config.search_builder_class = VisibilitySearchBuilder
+          end
+        end
+      end
+
+      it 'returns nothing for a restricted work' do
+        expect(wrapper.find('2007020969')).to be_nil
+      end
+
+      it 'returns a single record for a public work' do
+        expect(wrapper.find('2005553155')).to be_a SolrDocument
+      end
+    end
+  end
+end

data/spec/lib/blacklight_oai_provider/solr_document_provider_spec.rb

@@ -32,19 +32,34 @@ RSpec.describe BlacklightOaiProvider::SolrDocumentProvider do
     end
 
     context 'with Procs provided as option values' do
+      let(:alternate_controller) { AlternateController.new }
+      let(:alternate_provider) { described_class.new(alternate_controller, options) }
+      let(:alternate_view_context) { instance_double("ViewContext") }
       let(:options) do
         {
           provider: {
-            repository_name: ->(kontroller) { "Hello #{kontroller.__id__}" },
-            repository_url: ->(kontroller) { "Hello #{kontroller.view_context.oai_catalog_url}" }
+            repository_name: ->(kontroller) { "Hello #{kontroller.controller_name.titleize}" },
+            repository_url: ->(kontroller) { "Hello #{kontroller.view_context.send "oai_#{kontroller.controller_name}_url"}" }
           }
         }
       end
 
+      before do
+        allow(alternate_controller).to receive(:view_context).and_return(alternate_view_context)
+        allow(alternate_view_context).to receive(:oai_alternate_url).and_return(:another_path)
+        allow(alternate_view_context).to receive(:application_name).and_return(:another_name)
+      end
+
       it 'call()-s the Proc to set the option value' do
-        expect(provider.name).to eq "Hello #{controller.__id__}"
+        expect(provider.name).to eq "Hello Catalog"
         expect(provider.url).to eq "Hello #{controller.view_context.oai_catalog_url}"
       end
+
+      it 'does not pollute controller configurations from procs' do
+        provider.name
+        expect(alternate_provider.name).to eq "Hello Alternate"
+        expect(provider.name).to eq "Hello Catalog"
+      end
     end
   end
 end

data/spec/lib/blacklight_oai_provider/solr_document_wrapper_spec.rb

@@ -4,10 +4,12 @@ RSpec.describe BlacklightOaiProvider::SolrDocumentWrapper do
   subject(:wrapper) { described_class.new(controller, options) }
 
   let(:options) { {} }
-  let(:controller) { CatalogController.new }
+  let(:controller_class) { CatalogController }
+  let(:controller) { instance_double(CatalogController) }
+  let(:blacklight_config) { Blacklight::Configuration.new }
 
   before do
-    allow(controller).to receive(:params).and_return({})
+    allow(controller).to receive_messages(params: {}, blacklight_config: blacklight_config)
   end
 
   describe '#initialize' do
@@ -30,51 +32,224 @@ RSpec.describe BlacklightOaiProvider::SolrDocumentWrapper do
     end
   end
 
+  shared_context "timestamp_searches" do
+    let(:expected_timestamp) { '2014-02-03 18:42:53.056000000 +0000' }
+    let(:repository) { instance_double(Blacklight::Solr::Repository) }
+    let(:search_builder) { instance_double(Blacklight::SearchBuilder) }
+    let(:search_service) { instance_double(Blacklight::SearchService) }
+    let(:documents) { [SolrDocument.new('timestamp' => expected_timestamp)] }
+    let(:response) { OpenStruct.new(documents: documents, total: documents.length) }
+
+    before do
+      allow(controller).to receive(:search_service).and_return(search_service)
+      allow(search_service).to receive_messages(repository: repository, search_builder: search_builder)
+      allow(repository).to receive(:search).with(search_builder).and_return(response)
+    end
+  end
+
   describe '#earliest' do
+    include_context "timestamp_searches"
+
+    before do
+      allow(search_builder).to receive(:merge).with(hash_including(sort: "timestamp asc")).and_return(search_builder)
+    end
+
     it 'returns the earliest timestamp of all the records' do
-      expect(wrapper.earliest).to eq Time.parse('2014-02-03 18:42:53.056000000 +0000').utc
+      expect(wrapper.earliest).to eq Time.parse(expected_timestamp).utc
+    end
+
+    context "no documents are returned" do
+      let(:documents) { [] }
+
+      it 'returns a default timestamp' do
+        expect(Time.parse(wrapper.earliest).utc).to be_a Time
+      end
     end
   end
 
   describe '#latest' do
+    include_context "timestamp_searches"
+
+    before do
+      allow(search_builder).to receive(:merge).with(hash_including(sort: "timestamp desc")).and_return(search_builder)
+    end
+
     it 'returns the latest timestamp of all the records' do
-      expect(wrapper.latest).to eq Time.parse('2015-02-03 18:42:53.056000000 +0000').utc
+      expect(wrapper.latest).to eq Time.parse(expected_timestamp).utc
+    end
+
+    context "no documents are returned" do
+      let(:documents) { [] }
+
+      it 'returns a default timestamp' do
+        expect(Time.parse(wrapper.latest).utc).to be_a Time
+      end
     end
   end
 
   describe '#find' do
+    include_context "timestamp_searches"
+
+    subject(:result) { wrapper.find(selector) }
+
     context 'when selector is :all' do
+      let(:selector) { :all }
+      let(:query) { {} }
+      let(:limit) { 1 }
+      let(:options) { { limit: limit } }
+      let(:response) { OpenStruct.new(documents: documents, total: limit + 1) }
+      let(:next_response) { OpenStruct.new(documents: documents, total: documents.length) }
+
+      before do
+        allow(search_builder).to receive_messages(merge: search_builder, query: query)
+        allow(repository).to receive(:search).with(query).and_return(response)
+        allow(repository).to receive(:search).with(hash_including(start: 0)).and_return(next_response)
+      end
+
       it 'returns a limited list of all records' do
-        expect(wrapper.find(:all)).to be_a OAI::Provider::PartialResult
-        expect(wrapper.find(:all).records.size).to be 15
+        expect(result).to be_a OAI::Provider::PartialResult
+        expect(result.records.size).to be limit
+      end
+    end
+
+    context 'when selector is an id value' do
+      let(:selector) { '2007020969' }
+      let(:query) { {} }
+
+      before do
+        allow(search_builder).to receive(:query).and_return(query)
+        allow(repository).to receive(:search).with(query).and_return(response)
+        allow(search_builder).to receive(:where).with(id: selector).and_return(search_builder)
+      end
+
+      it 'searches by id' do
+        expect(result).to be_a(SolrDocument)
+        expect(search_builder).to have_received(:where).with(id: selector)
       end
     end
+  end
+
+  describe '#conditions' do
+    include_context "timestamp_searches"
 
-    context 'when selector is an individual record' do
-      class VisibilityAwareSearchBuilder < Blacklight::SearchBuilder
+    subject(:result) { wrapper.conditions(constraints) }
+
+    let(:search_builder_class) do
+      Class.new(Blacklight::SearchBuilder) do
         include Blacklight::Solr::SearchBuilderBehavior
-        self.default_processor_chain += [:only_visible]
+      end
+    end
+    let(:search_builder) { search_builder_class.new(controller) }
 
-        def only_visible(solr_parameters)
-          solr_parameters[:fq] ||= []
-          solr_parameters[:fq] << 'visibility_si:"open"'
-        end
+    context 'time options' do
+      let(:constraints) { { from: Time.utc(2015, 1, 1), until: Time.utc(2015, 1, 2) } }
+
+      it 'sets options when from' do
+        constraints.delete(:until)
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01T00:00:00Z TO *]"],
+          "sort" => "timestamp asc"
+        )
       end
 
-      before do
-        allow(controller).to receive(:search_builder_class).and_return(VisibilityAwareSearchBuilder)
+      it 'sets options when until' do
+        constraints.delete(:from)
+        expect(result).to include(
+          "fq" => ["timestamp:[* TO 2015-01-02T00:00:00.999Z]"],
+          "sort" => "timestamp asc"
+        )
       end
 
-      context 'with a restricted work' do
-        it 'returns nothing' do
-          expect(wrapper.find('2007020969')).to be_nil
-        end
+      it 'sets options when range' do
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01T00:00:00Z TO 2015-01-02T00:00:00.999Z]"],
+          "sort" => "timestamp asc"
+        )
+      end
+    end
+
+    context 'date options' do
+      let(:constraints) { { from: Date.parse('2015-01-01'), until: Date.parse('2015-01-02') } }
+
+      it 'sets options for high granularity' do
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01T00:00:00Z TO 2015-01-02T23:59:59.999Z]"],
+          "sort" => "timestamp asc"
+        )
       end
+      # rubocop:disable RSpec/NestedGroups
+      context 'low granularity' do
+        let(:options) { { granularity: OAI::Const::Granularity::LOW } }
 
-      context 'with a public work' do
-        it 'returns a single record' do
-          expect(wrapper.find('2005553155')).to be_a SolrDocument
+        it 'sets options' do
+          expect(wrapper.granularity).to eql(OAI::Const::Granularity::LOW)
+          expect(result).to include(
+            "fq" => ["timestamp:[2015-01-01 TO 2015-01-02]"],
+            "sort" => "timestamp asc"
+          )
         end
+        context 'same value for endpoints' do
+          let(:constraints) { { from: Date.parse('2015-01-01'), until: Date.parse('2015-01-01') } }
+
+          it 'sets options' do
+            expect(wrapper.granularity).to eql(OAI::Const::Granularity::LOW)
+            expect(result).to include(
+              "fq" => ["timestamp:\"2015-01-01\""],
+              "sort" => "timestamp asc"
+            )
+          end
+        end
+      end
+      # rubocop:enable RSpec/NestedGroups
+    end
+
+    context 'string date options' do
+      let(:constraints) { { from: '2015-01-01', until: '2015-01-02' } }
+
+      it 'sets options when from' do
+        constraints.delete(:until)
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01 TO *]"],
+          "sort" => "timestamp asc"
+        )
+      end
+      it 'sets options when until' do
+        constraints.delete(:from)
+        expect(result).to include(
+          "fq" => ["timestamp:[* TO 2015-01-02]"],
+          "sort" => "timestamp asc"
+        )
+      end
+      it 'sets options when range' do
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01 TO 2015-01-02]"],
+          "sort" => "timestamp asc"
+        )
+      end
+    end
+
+    context 'string time options' do
+      let(:constraints) { { from: '2015-01-01T00:00:00.000Z', until: '2015-01-02T00:00:00.000Z' } }
+
+      it 'sets options when from' do
+        constraints.delete(:until)
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01T00:00:00.000Z TO *]"],
+          "sort" => "timestamp asc"
+        )
+      end
+      it 'sets options when until' do
+        constraints.delete(:from)
+        expect(result).to include(
+          "fq" => ["timestamp:[* TO 2015-01-02T00:00:00.000Z]"],
+          "sort" => "timestamp asc"
+        )
+      end
+      it 'sets options when range' do
+        expect(result).to include(
+          "fq" => ["timestamp:[2015-01-01T00:00:00.000Z TO 2015-01-02T00:00:00.000Z]"],
+          "sort" => "timestamp asc"
+        )
       end
     end
   end