blacklight_oai_provider 6.0.0 → 7.0.2

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",
@@ -29,7 +29,7 @@ describe CatalogController do
       )
     end
 
-    it 'return corrext document configuration' do
+    it 'return correct document configuration' do
       expect(controller.oai_config[:document][:limit]).to be 25
     end
   end

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

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+RSpec.describe BlacklightOaiProvider::SolrDocumentProvider do
+  subject(:provider) { described_class.new(controller, options) }
+
+  let(:options) { {} }
+  let(:controller) { CatalogController.new }
+
+  describe '#initialize' do
+    let(:view_context) { instance_double("ViewContext") }
+
+    before do
+      allow(controller).to receive(:view_context).and_return(view_context)
+      allow(view_context).to receive(:oai_catalog_url).and_return(:some_path)
+      allow(view_context).to receive(:application_name).and_return(:some_name)
+    end
+
+    context 'with no options provided' do
+      it 'sets the default repository name and url' do
+        expect(provider.url).to eq :some_path
+        expect(provider.name).to eq :some_name
+      end
+    end
+
+    context 'with options provided' do
+      let(:options) { { provider: { repository_url: '/my/custom/path', repository_name: 'My Custom Name' } } }
+
+      it 'uses the repository name and url set into the options' do
+        expect(provider.url).to eq '/my/custom/path'
+        expect(provider.name).to eq 'My Custom Name'
+      end
+    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.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 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,29 +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('2014-03-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 individual record' do
-      it 'returns a single record' do
-        expect(wrapper.find('2005553155')).to be_a SolrDocument
+    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"
+
+    subject(:result) { wrapper.conditions(constraints) }
+
+    let(:search_builder_class) do
+      Class.new(Blacklight::SearchBuilder) do
+        include Blacklight::Solr::SearchBuilderBehavior
+      end
+    end
+    let(:search_builder) { search_builder_class.new(controller) }
+
+    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
+
+      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
+
+      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 } }
+
+        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

data/spec/lib/blacklight_oai_provider/solr_set_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 RSpec.describe BlacklightOaiProvider::SolrSet do
   let(:controller) { CatalogController.new }
   let(:fields) do
-    [{ label: 'language', solr_field: 'language_facet' }]
+    [{ label: 'language', solr_field: 'language_ssim' }]
   end
 
   before do
@@ -23,7 +23,7 @@ RSpec.describe BlacklightOaiProvider::SolrSet do
     context 'with multiple fields' do
       let(:fields) do
         [
-          { label: 'language', solr_field: 'language_facet' },
+          { label: 'language', solr_field: 'language_ssim' },
           { solr_field: 'format' }
         ]
       end
@@ -35,7 +35,7 @@ RSpec.describe BlacklightOaiProvider::SolrSet do
 
     context 'for a field with no values' do
       let(:fields) do
-        [{ label: 'author', solr_field: 'author_display' }]
+        [{ label: 'author', solr_field: 'author_ts' }]
       end
 
       it 'returns nil' do
@@ -45,12 +45,12 @@ RSpec.describe BlacklightOaiProvider::SolrSet do
 
     context 'for a field with facet config limit' do
       let(:fields) do
-        [{ label: 'lc_alpha', solr_field: 'lc_alpha_facet' }]
+        [{ label: 'lc_alpha', solr_field: 'lc_alpha_ssim' }]
       end
 
       before do
         CatalogController.configure_blacklight do |config|
-          config.add_facet_field 'lc_alpha_facet', label: 'lc_alpha', limit: 2
+          config.add_facet_field 'lc_alpha_ssim', label: 'lc_alpha', limit: 2
         end
       end
 
@@ -65,7 +65,7 @@ RSpec.describe BlacklightOaiProvider::SolrSet do
       let(:spec) { 'language:Hebrew' }
 
       it 'returns the filter query' do
-        expect(described_class.from_spec(spec)).to eq 'language_facet:"Hebrew"'
+        expect(described_class.from_spec(spec)).to eq 'language_ssim:"Hebrew"'
       end
     end
 
@@ -94,7 +94,7 @@ RSpec.describe BlacklightOaiProvider::SolrSet do
     end
 
     it 'gets solr field' do
-      expect(set.solr_field).to eql 'language_facet'
+      expect(set.solr_field).to eql 'language_ssim'
     end
   end
 end

data/spec/requests/identify_spec.rb

@@ -12,7 +12,7 @@ describe 'OIA-PMH Identify Request' do
   end
 
   it "contains repository name" do
-    expect(xml.at_xpath('//xmlns:repositoryName').text).to eql 'Test Repository'
+    expect(xml.at_xpath('//xmlns:repositoryName').text).to eql 'Catalog Repository'
   end
 
   it "contains base url" do

data/spec/requests/list_identifiers_spec.rb

@@ -18,7 +18,7 @@ describe 'OIA-PMH ListIdentifiers Request' do
     end
 
     it 'contains resumptionToken' do
-      expect(xml.at_xpath('//xmlns:resumptionToken').text).to eql 'oai_dc.f(2014-02-03T18:42:53Z).u(2014-03-03T18:42:53Z).t(30):25'
+      expect(xml.at_xpath('//xmlns:resumptionToken').text).to eql 'oai_dc.f(2014-02-03T18:42:53Z).u(2015-02-03T18:42:53Z).t(30):25'
     end
   end
 
@@ -27,8 +27,8 @@ describe 'OIA-PMH ListIdentifiers Request' do
       get '/catalog/oai?verb=ListIdentifiers&resumptionToken=oai_dc.f(2014-02-03T18:42:53Z).u(2014-03-03T18:42:53Z).t(30):25'
     end
 
-    it 'returns 5 records' do
-      expect(xml.xpath('//xmlns:ListIdentifiers/xmlns:header').count).to be 5
+    it 'returns 4 records' do
+      expect(xml.xpath('//xmlns:ListIdentifiers/xmlns:header').count).to be 4
     end
 
     it 'first record has identifier and timestamp' do
@@ -57,7 +57,7 @@ describe 'OIA-PMH ListIdentifiers Request' do
 
   context 'with different timestamp_field' do
     before :all do
-      SolrDocument.timestamp_key = "record_creation_dt"
+      SolrDocument.timestamp_key = "record_creation_dtsi"
     end
 
     before do

data/spec/requests/list_records_spec.rb

@@ -24,7 +24,7 @@ describe 'OIA-PMH ListRecords Request' do
     end
 
     it 'contains resumptionToken' do
-      expect(xml.at_xpath('//xmlns:resumptionToken').text).to eql 'oai_dc.f(2014-02-03T18:42:53Z).u(2014-03-03T18:42:53Z).t(30):25'
+      expect(xml.at_xpath('//xmlns:resumptionToken').text).to eql 'oai_dc.f(2014-02-03T18:42:53Z).u(2015-02-03T18:42:53Z).t(30):25'
     end
 
     context 'for record' do
@@ -73,8 +73,8 @@ describe 'OIA-PMH ListRecords Request' do
       get '/catalog/oai?verb=ListRecords&resumptionToken=oai_dc.f(2014-02-03T18:42:53Z).u(2014-02-03T18:42:53Z).t(29):25'
     end
 
-    it 'returns 4 records' do
-      expect(xml.xpath('//xmlns:ListRecords/xmlns:record/xmlns:header').count).to be 4
+    it 'returns 3 records' do
+      expect(xml.xpath('//xmlns:ListRecords/xmlns:record/xmlns:header').count).to be 3
     end
 
     it 'first record has oai_dc metadata element' do
@@ -119,7 +119,7 @@ describe 'OIA-PMH ListRecords Request' do
 
   context 'throws noRecordsMatch error' do
     before do
-      get '/catalog/oai?verb=ListRecords&metadataPrefix=oai_dc&from=2015-01-01'
+      get '/catalog/oai?verb=ListRecords&metadataPrefix=oai_dc&from=2016-01-01'
     end
 
     it 'returns no records error' do

data/spec/requests/list_sets_spec.rb

@@ -57,7 +57,7 @@ RSpec.describe 'OAI-PMH ListSets Request' do
       {
         document: {
           set_fields: [
-            { label: 'subject', solr_field: 'subject_topic_facet',
+            { label: 'subject', solr_field: 'subject_ssim',
               description: "Subject topic set using FAST subjects" }
           ]
         }

data/spec/spec_helper.rb

@@ -6,18 +6,9 @@ EngineCart.load_application!
 require 'rspec/rails'
 require 'capybara/rspec'
 require 'selenium-webdriver'
+require 'webdrivers'
 
-Capybara.javascript_driver = :headless_chrome
-
-Capybara.register_driver :headless_chrome do |app|
-  capabilities = Selenium::WebDriver::Remote::Capabilities.chrome(
-    chromeOptions: { args: %w[headless disable-gpu] }
-  )
-
-  Capybara::Selenium::Driver.new(app,
-                                 browser: :chrome,
-                                 desired_capabilities: capabilities)
-end
+Capybara.javascript_driver = :selenium_chrome_headless
 
 RSpec.configure do |config|
   config.infer_spec_type_from_file_location!

data/spec/test_app_templates/lib/generators/test_app_generator.rb

@@ -11,6 +11,7 @@ class TestAppGenerator < Rails::Generators::Base
     say_status("warning", "GENERATING BL", :yellow)
 
     generate 'blacklight:install', '--devise'
+    generate 'blacklight:test_support'
   end
 
   def change_migrations_if_rails_4_2
@@ -51,14 +52,35 @@ class TestAppGenerator < Rails::Generators::Base
     generate 'blacklight_oai_provider:install'
   end
 
-  def add_test_blacklight_oai_config
+  def add_test_blacklight_oai_controller_config
+    %w[catalog alternate].each { |cn| add_test_config_for(cn) }
+  end
+
+  def add_test_blacklight_oai_model_config
+    insert_into_file "app/models/solr_document.rb", after: "include BlacklightOaiProvider::SolrDocument\n" do
+      <<-CONFIG
+  field_semantics.merge!(
+    title: "title_tsim",
+    date: "pub_date_ssim",
+    subject: "subject_ssim",
+    creator: "author_tsim",
+    format: "format",
+    language: "language_ssim",
+  )
+      CONFIG
+    end
+  end
+
+  private
+
+  def add_test_config_for(controller_basename)
     say_status("warning", "ADDING BL OIA-PMH CONFIG")
 
-    insert_into_file "app/controllers/catalog_controller.rb", after: "config.default_solr_params = {" do
+    insert_into_file "app/controllers/#{controller_basename}_controller.rb", after: "config.default_solr_params = {" do
       "\n      fl: '*',\n"
     end
 
-    insert_into_file "app/controllers/catalog_controller.rb", after: "  configure_blacklight do |config|\n" do
+    insert_into_file "app/controllers/#{controller_basename}_controller.rb", after: "  configure_blacklight do |config|\n" do
       <<-CONFIG
     config.default_document_solr_params = {
       qt: 'search',
@@ -69,12 +91,12 @@ class TestAppGenerator < Rails::Generators::Base
       CONFIG
     end
 
-    insert_into_file "app/controllers/catalog_controller.rb", after: "configure_blacklight do |config|\n" do
+    insert_into_file "app/controllers/#{controller_basename}_controller.rb", after: "configure_blacklight do |config|\n" do
       <<-CONFIG
     config.oai = {
       provider: {
-        repository_name: 'Test Repository',
-        repository_url: 'http://localhost/catalog/oai',
+        repository_name: '#{controller_basename.titleize} Repository',
+        repository_url: 'http://localhost/#{controller_basename}/oai',
         record_prefix: 'oai:test',
         admin_email: 'root@localhost',
         deletion_support: 'persistent',
@@ -82,25 +104,12 @@ class TestAppGenerator < Rails::Generators::Base
       },
       document: {
         set_fields: [
-          { label: 'language', solr_field: 'language_facet' }
+          { label: 'language', solr_field: 'language_ssim' }
         ],
         limit: 25
       }
     }
       CONFIG
     end
-
-    insert_into_file "app/models/solr_document.rb", after: "include BlacklightOaiProvider::SolrDocument\n" do
-      <<-CONFIG
-  field_semantics.merge!(
-    title: "title_display",
-    creator: "author_display",
-    date: "pub_date",
-    subject: "subject_topic_facet",
-    format: "format",
-    language: "language_facet"
-  )
-      CONFIG
-    end
   end
 end