blacklight 5.11.3 → 5.12.0

data/spec/helpers/facets_helper_spec.rb

@@ -107,88 +107,15 @@ describe FacetsHelper do
 
   describe "facet_by_field_name" do
     it "should retrieve the facet from the response given a string" do
-      facet_config = double(:query => nil, field: 'a')
+      facet_config = double(:query => nil, field: 'a', key: 'a')
       facet_field = double()
       allow(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
 
       @response = double()
-      allow(@response).to receive(:facet_by_field_name).with('a').and_return(facet_field)
+      allow(@response).to receive(:aggregations).and_return('a' => facet_field)
 
       expect(helper.facet_by_field_name('a')).to eq facet_field
     end
-
-    it "should also work for facet query fields" do
-      facet_config = double(:query => {}, key: 'a_query_facet_field')
-      allow(helper).to receive(:facet_configuration_for_field).with('a_query_facet_field').and_return(facet_config)
-      allow(helper).to receive(:create_facet_field_response_for_query_facet_field).with('a_query_facet_field', facet_config)
-
-      helper.facet_by_field_name 'a_query_facet_field'
-    end
-
-    describe "query facets" do
-      let(:facet_config) { 
-        double(
-          key: 'my_query_facet_field',
-          :query => {
-             'a_simple_query' => { :fq => 'field:search', :label => 'A Human Readable label'},
-             'another_query' => { :fq => 'field:different_search', :label => 'Label'},
-             'without_results' => { :fq => 'field:without_results', :label => 'No results for this facet'}
-             }
-        )
-      }
-
-      before(:each) do
-        allow(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
-
-        @response = double(:facet_queries => {
-          'field:search' => 10,
-          'field:different_search' => 2,
-          'field:not_appearing_in_the_config' => 50,
-          'field:without_results' => 0
-        })
-      end
-
-      it"should convert the query facets into a double RSolr FacetField" do
-        field = helper.facet_by_field_name('my_query_facet_field')
-        expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
-
-        expect(field.name).to eq'my_query_facet_field'
-        expect(field.items.size).to eq 2
-        expect(field.items.map { |x| x.value }).to_not include 'field:not_appearing_in_the_config'
-
-        facet_item = field.items.select { |x| x.value == 'a_simple_query' }.first
-
-        expect(facet_item.value).to eq 'a_simple_query'
-        expect(facet_item.hits).to eq 10
-        expect(facet_item.label).to eq 'A Human Readable label'
-      end
-    end
-
-    describe "pivot facets" do
-      let(:facet_config) {
-        double(key: 'my_pivot_facet_field', pivot: ['field_a', 'field_b'])
-      }
-
-      before(:each) do 
-        allow(helper).to receive(:facet_configuration_for_field).with(anything()).and_return(facet_config)
-      
-        @response = double(:facet_pivot => { 'field_a,field_b' => [{:field => 'field_a', :value => 'a', :count => 10, :pivot => [{:field => 'field_b', :value => 'b', :count => 2}]}]})
-      end
-
-      it "should convert the pivot facet into a double RSolr FacetField" do
-        field = helper.facet_by_field_name('my_pivot_facet_field')
-        expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
-
-        expect(field.name).to eq 'my_pivot_facet_field'
-
-        expect(field.items.size).to eq 1
-
-        expect(field.items.first).to respond_to(:items)
-
-        expect(field.items.first.items.size).to eq 1
-        expect(field.items.first.items.first.fq).to eq({ 'field_a' => 'a' })
-      end
-    end
   end
 
 
@@ -320,8 +247,43 @@ describe FacetsHelper do
     end
   end
 
+  describe "facet_params" do
+    it "should extract the facet parameters for a field" do
+      allow(helper).to receive_messages(params: { f: { "some-field" => ["x"] }})
+      expect(helper.facet_params("some-field")).to match_array ["x"]
+    end
+
+    it "should use the blacklight key to extract the right fields" do
+      blacklight_config.add_facet_field "some-key", field: "some-field"
+      allow(helper).to receive_messages(params: { f: { "some-key" => ["x"] }})
+      expect(helper.facet_params("some-key")).to match_array ["x"]
+      expect(helper.facet_params("some-field")).to match_array ["x"]
+    end
+  end
+
+  describe "facet_field_in_params?" do
+    it "should check if any value is selected for a given facet" do
+      allow(helper).to receive_messages(facet_params: ["x"])
+      expect(helper.facet_field_in_params?("some-facet")).to eq true
+    end
+
+    it "should be false if no value for facet is selected" do
+      allow(helper).to receive_messages(facet_params: nil)
+      expect(helper.facet_field_in_params?("some-facet")).to eq false
+    end
+  end
+
   describe "facet_in_params?" do
+    it "should check if a particular value is set in the facet params" do
+      allow(helper).to receive_messages(facet_params: ["x"])
+      expect(helper.facet_in_params?("some-facet", "x")).to eq true
+      expect(helper.facet_in_params?("some-facet", "y")).to eq false
+    end
 
+    it "should be false if no value for facet is selected" do
+      allow(helper).to receive_messages(facet_params: nil)
+      expect(helper.facet_in_params?("some-facet", "x")).to eq false
+    end
   end
 
   describe "render_facet_value" do

data/spec/helpers/url_helper_spec.rb

@@ -273,7 +273,7 @@ describe BlacklightUrlHelper do
     it "should accept and return a Proc" do
       data = {'id'=>'123456','title_display'=>['654321'] }
       @document = SolrDocument.new(data)
-      expect(helper.link_to_document(@document, Proc.new { |doc, opts| doc.get(:id) + ": " + doc.get(:title_display) })).to have_selector("a", :text => '123456: 654321', :count => 1)
+      expect(helper.link_to_document(@document, Proc.new { |doc, opts| doc[:id] + ": " + doc.first(:title_display) })).to have_selector("a", :text => '123456: 654321', :count => 1)
     end
 
     it "should return id when label is missing" do

data/spec/lib/blacklight/configuration_spec.rb

@@ -207,13 +207,25 @@ describe "Blacklight::Configuration" do
       expect { @config.add_facet_field(nil) }.to raise_error ArgumentError
     end
 
-    it "should take wild-carded field names and dereference them to solr fields" do
+    it "should look up and match field names" do
       allow(@config).to receive_messages(luke_fields: { 
         "some_field_facet" => {}, 
         "another_field_facet" => {},
         "a_facet_field" => {},
         })
+      expect { |b| @config.add_facet_field match: /_facet$/, &b }.to yield_control.twice
+
+      expect(@config.facet_fields.keys).to eq ["some_field_facet", "another_field_facet"]
+    end
+
+    it "should take wild-carded field names and dereference them to solr fields" do
+      allow(@config).to receive_messages(luke_fields: {
+        "some_field_facet" => {},
+        "another_field_facet" => {},
+        "a_facet_field" => {},
+        })
       expect { |b| @config.add_facet_field "*_facet", &b }.to yield_control.twice
+
       expect(@config.facet_fields.keys).to eq ["some_field_facet", "another_field_facet"]
     end
 
@@ -275,6 +287,11 @@ describe "Blacklight::Configuration" do
 
       expect(@config.index_fields.keys).to eq ["some_field_display", "another_field_display"]
     end
+
+    it "should query solr and get live values for match fields", integration: true do
+      @config.add_index_field match: /title.+display/
+      expect(@config.index_fields.keys).to include "subtitle_display", "subtitle_vern_display", "title_display", "title_vern_display"
+    end
   end
   
   describe "add_show_field" do

data/spec/lib/blacklight/document_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe Blacklight::Document do
+  let(:data) { {} }
+  subject do
+    Class.new do
+      include Blacklight::Document
+    end.new(data)
+  end
+
+  describe "#has?" do
+    context "without value constraints" do
+      it "should have the field if the field is in the data" do
+        data[:x] = true
+        expect(subject).to have_field(:x)
+      end
+      
+      it "should not have the field if the field is not in the data" do
+        expect(subject).not_to have_field(:x)
+      end
+    end
+
+    context "with regular value constraints" do
+      it "should have the field if the data has that value" do
+        data[:x] = true
+        expect(subject).to have_field(:x, true)
+      end
+      
+      it "should not have the field if the data does not have that value" do
+        data[:x] = false
+        expect(subject).not_to have_field(:x, true)
+      end
+
+      it "should allow multiple value constraints" do
+        data[:x] = false
+        expect(subject).to have_field(:x, true, false)
+      end
+
+      it "should support multivalued fields" do
+        data[:x] = ["a", "b", "c"]
+        expect(subject).to have_field(:x, "a")
+      end
+
+      it "should support multivalued fields with an array of value constraints" do
+        data[:x] = ["a", "b", "c"]
+        expect(subject).to have_field(:x, "a", "d")
+      end
+    end
+
+    context "with regexp value constraints" do
+      it "should check if the data matches the constraint" do
+        data[:x] = "the quick brown fox"
+        expect(subject).to have_field(:x, /fox/)
+      end
+
+      it "should support multivalued fields" do
+        data[:x] = ["the quick brown fox", "and the lazy dog"]
+        expect(subject).to have_field(:x, /fox/)
+      end
+    end
+  end
+end

data/spec/lib/blacklight/search_builder_spec.rb

@@ -100,31 +100,33 @@ describe Blacklight::SearchBuilder do
   end
 
   describe "#rows" do
-    it "should be the per_page parameter" do
-      expect(subject.with(per_page: 5).send(:rows)).to eq 5
+
+    it "should be nil if no value is set" do
+      blacklight_config.default_per_page = nil
+      blacklight_config.per_page = []
+      expect(subject.rows).to be_nil
     end
 
-    it "should support the legacy 'rows' parameter" do
-      expect(subject.with(rows: 10).send(:rows)).to eq 10
+    it "should set the number of rows" do
+      expect(subject.rows(17).rows).to eq 17
     end
 
-    it "should use the provided default" do
-      expect(subject.send(:rows, 17)).to eq 17
+    it "should be the per_page parameter" do
+      expect(subject.with(per_page: 5).rows).to eq 5
     end
 
-    it "should be set to the configured default" do
-      blacklight_config.default_per_page = 42
-      expect(subject.send(:rows)).to eq 42
+    it "should support the legacy 'rows' parameter" do
+      expect(subject.with(rows: 10).rows).to eq 10
     end
 
-    it "should default to 10" do
-      blacklight_config.default_per_page = nil
-      expect(subject.send(:rows)).to eq 10
+    it "should be set to the configured default" do
+      blacklight_config.default_per_page = 42
+      expect(subject.rows).to eq 42
     end
 
     it "should limit the number of rows to the configured maximum" do
       blacklight_config.max_per_page = 1000
-      expect(subject.send(:rows, 1001)).to eq 1000
+      expect(subject.rows(1001).rows).to eq 1000
     end
   end
 

data/spec/lib/blacklight/search_helper_spec.rb

@@ -138,6 +138,7 @@ describe Blacklight::SearchHelper do
 
   describe "get_facet_pagination", :integration => true do
     before do
+      @facet_field = 'format'
       Deprecation.silence(Blacklight::SearchHelper) do
         @facet_paginator = subject.get_facet_pagination(@facet_field)
       end
@@ -195,8 +196,8 @@ describe Blacklight::SearchHelper do
         (solr_response, document_list) = subject.get_search_results(q: @all_docs_query)
         result_docs = document_list
         document = result_docs.first
-        expect(document.get(blacklight_config.index.title_field)).not_to be_nil
-        expect(document.get(blacklight_config.index.display_type_field)).not_to be_nil
+        expect(document.fetch(blacklight_config.index.title_field)).not_to be_nil
+        expect(document.fetch(blacklight_config.index.display_type_field)).not_to be_nil
       end
     end
 
@@ -252,8 +253,8 @@ describe Blacklight::SearchHelper do
         (solr_response, document_list) = subject.search_results({ q: @all_docs_query }, default_method_chain)
         result_docs = document_list
         document = result_docs.first
-        expect(document.get(blacklight_config.index.title_field)).not_to be_nil
-        expect(document.get(blacklight_config.index.display_type_field)).not_to be_nil
+        expect(document.fetch(blacklight_config.index.title_field)).not_to be_nil
+        expect(document.fetch(blacklight_config.index.display_type_field)).not_to be_nil
       end
     end
 
@@ -357,27 +358,25 @@ describe Blacklight::SearchHelper do
 
     before do
       (solr_response, document_list) = subject.search_results({ q: @all_docs_query}, default_method_chain)
-      @facets = solr_response.facets
+      @facets = solr_response.aggregations
     end
 
     it 'should have more than one facet' do
       expect(@facets).to have_at_least(1).facet
     end
     it 'should have all facets specified in initializer' do
-      fields = blacklight_config.facet_fields.reject { |k,v| v.query || v.pivot }
-      expect(@facets.map { |f| f.name }).to match_array fields.map { |k, v| v.field }
-      fields.each do |key, field|
-        expect(@facets.find {|f| f.name == field.field}).not_to be_nil        
-      end
+      expect(@facets.keys).to include *blacklight_config.facet_fields.keys
+      expect(@facets.none? { |k, v| v.nil? }).to eq true
     end
+
     it 'should have at least one value for each facet' do
-      @facets.each do |facet|
+      @facets.each do |key, facet|
         expect(facet.items).to have_at_least(1).hit
       end
     end
     it 'should have multiple values for at least one facet' do
       has_mult_values = false
-      @facets.each do |facet|
+      @facets.each do |key, facet|
         if facet.items.size > 1
           has_mult_values = true
           break
@@ -386,7 +385,7 @@ describe Blacklight::SearchHelper do
       expect(has_mult_values).to eq true
     end
     it 'should have all value counts > 0' do
-      @facets.each do |facet|
+      @facets.each do |key, facet|
         facet.items.each do |facet_vals|
           expect(facet_vals.hits).to be > 0
         end
@@ -503,7 +502,7 @@ describe Blacklight::SearchHelper do
       expect(@document.id).to eq @doc_id
     end
     it 'should have non-nil values for required fields set in initializer' do
-      expect(@document.get(blacklight_config.view_config(:show).display_type_field)).not_to be_nil
+      expect(@document.fetch(blacklight_config.view_config(:show).display_type_field)).not_to be_nil
     end
   end
 
@@ -676,14 +675,14 @@ describe Blacklight::SearchHelper do
       end
       it "should get from @response facet.limit if available" do        
         @response = double()
-        allow(@response).to receive(:facet_by_field_name).with("language_facet").and_return(double(limit: nil))
+        allow(@response).to receive(:aggregations).and_return("language_facet" => double(limit: nil))
         subject.instance_variable_set(:@response, @response)
         blacklight_config.facet_fields['language_facet'].limit = 10
         expect(subject.facet_limit_for("language_facet")).to eq 10
       end
       it "should get the limit from the facet field in @response" do
         @response = double()
-        allow(@response).to receive(:facet_by_field_name).with("language_facet").and_return(double(limit: 16))
+        allow(@response).to receive(:aggregations).and_return("language_facet" => double(limit: 16))
         subject.instance_variable_set(:@response, @response)
         expect(subject.facet_limit_for("language_facet")).to eq 15
       end

data/spec/lib/blacklight/solr/document_spec.rb

@@ -25,9 +25,11 @@ describe "Blacklight::Solr::Document" do
         expect(doc.has?(:cat, 'elec')).not_to eq true
         expect(doc.has?(:cat, 'electronics')).to eq true
 
-        expect(doc.get(:cat)).to eq 'electronics, hard drive'
-        expect(doc.get(:xyz)).to be_nil
-        expect(doc.get(:xyz, :default=>'def')).to eq 'def'
+        expect(doc.fetch(:cat)).to eq ['electronics', 'hard drive']
+        expect(doc.fetch(:xyz, nil)).to be_nil
+        expect(doc.fetch(:xyz, 'def')).to eq 'def'
+        expect(doc.fetch(:xyz) { |el| 'def' }).to eq 'def'
+        expect { doc.fetch(:xyz) }.to raise_exception(KeyError)
       end
     end
 

data/spec/lib/blacklight/solr/search_builder_spec.rb

@@ -40,7 +40,6 @@ describe Blacklight::Solr::SearchBuilder do
                              :qf => "fieldOne^2.3 fieldTwo fieldThree^0.4",
                              :pf => "",
                              :spellcheck => 'false',
-                             :rows => "55",
                              :sort => "request_params_sort" }
                           )
       end
@@ -62,10 +61,6 @@ describe Blacklight::Solr::SearchBuilder do
         expect(subject[:qt]).to eq blacklight_config[:default_solr_params][:qt]
       end
 
-      it "should take rows from search field definition where specified" do
-        expect(subject[:rows]).to eq "55"
-      end
-
       it "should take q from request params" do
         expect(subject[:q]).to eq "test query"
       end

data/spec/lib/blacklight/solr_response/facets_spec.rb

@@ -22,7 +22,32 @@ describe Blacklight::SolrResponse::Facets do
     end
   end
 
+  describe "#facets" do
+    subject { Blacklight::SolrResponse.new({}, {}) }
+    let(:aggregations) { { x: 1, y: 2 } } 
+    it "should get the aggregation values" do
+      allow(subject).to receive(:aggregations).and_return aggregations
+
+      Deprecation.silence(described_class) do
+        expect(subject.facets).to eq aggregations.values
+      end
+    end
+  end
+
   describe "#facet_by_field_name" do
+    subject { Blacklight::SolrResponse.new({}, {}) }
+    let(:aggregations) { { x: double } } 
+
+    it "should pull facets out of the aggregations" do
+      allow(subject).to receive(:aggregations).and_return aggregations
+
+      Deprecation.silence(described_class) do
+        expect(subject.facet_by_field_name(:x)).to eq aggregations[:x]
+      end
+    end
+  end
+
+  describe "#aggregations" do
     let(:facet_field) { ['my_field', []] }
     let(:response_header) { { params: request_params }}
     let(:request_params) { Hash.new }
@@ -32,16 +57,16 @@ describe Blacklight::SolrResponse::Facets do
       it "should extract a field-specific limit value" do
         request_params['f.my_field.facet.limit'] = "10"
         request_params['facet.limit'] = "15"
-        expect(subject.facet_by_field_name('my_field').limit).to eq 10
+        expect(subject.aggregations['my_field'].limit).to eq 10
       end
 
       it "should extract a global limit value" do
         request_params['facet.limit'] = "15"
-        expect(subject.facet_by_field_name('my_field').limit).to eq 15
+        expect(subject.aggregations['my_field'].limit).to eq 15
       end
 
       it "should be the solr default limit if no value is found" do
-        expect(subject.facet_by_field_name('my_field').limit).to eq 100
+        expect(subject.aggregations['my_field'].limit).to eq 100
       end
     end
 
@@ -49,16 +74,16 @@ describe Blacklight::SolrResponse::Facets do
       it "should extract a field-specific offset value" do
         request_params['f.my_field.facet.offset'] = "10"
         request_params['facet.offset'] = "15"
-        expect(subject.facet_by_field_name('my_field').offset).to eq 10
+        expect(subject.aggregations['my_field'].offset).to eq 10
       end
 
       it "should extract a global offset value" do
         request_params['facet.offset'] = "15"
-        expect(subject.facet_by_field_name('my_field').offset).to eq 15
+        expect(subject.aggregations['my_field'].offset).to eq 15
       end
 
       it "should be nil if no value is found" do
-        expect(subject.facet_by_field_name('my_field').offset).to eq 0
+        expect(subject.aggregations['my_field'].offset).to eq 0
       end
     end
 
@@ -66,22 +91,131 @@ describe Blacklight::SolrResponse::Facets do
       it "should extract a field-specific sort value" do
         request_params['f.my_field.facet.sort'] = "alpha"
         request_params['facet.sort'] = "index"
-        expect(subject.facet_by_field_name('my_field').sort).to eq 'alpha'
+        expect(subject.aggregations['my_field'].sort).to eq 'alpha'
       end
 
       it "should extract a global sort value" do
         request_params['facet.sort'] = "alpha"
-        expect(subject.facet_by_field_name('my_field').sort).to eq 'alpha'
+        expect(subject.aggregations['my_field'].sort).to eq 'alpha'
       end
 
       it "should default to count if no value is found and the default limit is used" do
-        expect(subject.facet_by_field_name('my_field').sort).to eq 'count'
+        expect(subject.aggregations['my_field'].sort).to eq 'count'
       end
       
       it "should default to index if no value is found and the limit is unlimited" do
         request_params['facet.limit'] = -1
-        expect(subject.facet_by_field_name('my_field').sort).to eq 'index'
+        expect(subject.aggregations['my_field'].sort).to eq 'index'
       end
     end
   end
+
+  context "facet.missing" do
+    let(:response) do
+      {
+        facet_counts: {
+          facet_fields: {
+            some_field: ['a', 1, nil, 2]
+          }
+        }
+      }
+    end
+    
+    subject { Blacklight::SolrResponse.new(response, {}) }
+
+    it "should mark the facet.missing field with a human-readable label and fq" do
+      missing = subject.aggregations["some_field"].items.select { |i| i.value.nil? }.first
+
+      expect(missing.label).to eq "[Missing]"
+      expect(missing.fq).to eq "-some_field:[* TO *]"
+    end
+  end
+
+  describe "query facets" do
+    let(:facet_config) { 
+      double(
+        key: 'my_query_facet_field',
+        :query => {
+           'a_simple_query' => { :fq => 'field:search', :label => 'A Human Readable label'},
+           'another_query' => { :fq => 'field:different_search', :label => 'Label'},
+           'without_results' => { :fq => 'field:without_results', :label => 'No results for this facet'}
+           }
+      )
+    }
+
+    let(:blacklight_config) { double(facet_fields: { 'my_query_facet_field' => facet_config } )}
+
+    let(:response) do
+      { 
+        facet_counts: {
+          facet_queries: {
+            'field:search' => 10,
+            'field:different_search' => 2,
+            'field:not_appearing_in_the_config' => 50,
+            'field:without_results' => 0
+          }
+        }
+      }
+    end
+
+    subject { Blacklight::SolrResponse.new(response, {}, blacklight_config: blacklight_config) }
+
+    it"should convert the query facets into a double RSolr FacetField" do
+      field = subject.aggregations['my_query_facet_field']
+
+      expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
+
+      expect(field.name).to eq'my_query_facet_field'
+      expect(field.items.size).to eq 2
+      expect(field.items.map { |x| x.value }).to_not include 'field:not_appearing_in_the_config'
+
+      facet_item = field.items.select { |x| x.value == 'a_simple_query' }.first
+
+      expect(facet_item.value).to eq 'a_simple_query'
+      expect(facet_item.hits).to eq 10
+      expect(facet_item.label).to eq 'A Human Readable label'
+    end
+  end
+
+  describe "pivot facets" do
+    let(:facet_config) {
+      double(key: 'my_pivot_facet_field', query: nil, pivot: ['field_a', 'field_b'])
+    }
+    
+    let(:blacklight_config) { double(facet_fields: { 'my_pivot_facet_field' => facet_config } )}
+
+    let(:response) do
+      { 
+        facet_counts: {
+          facet_pivot: { 
+            'field_a,field_b' => [
+              {
+                field: 'field_a', 
+                value: 'a', 
+                count: 10, 
+                pivot: [{field: 'field_b', value: 'b', count: 2}]
+              }]
+          }
+        }
+      }
+    end
+
+    subject { Blacklight::SolrResponse.new(response, {}, blacklight_config: blacklight_config) }
+
+    it "should convert the pivot facet into a double RSolr FacetField" do
+      field = subject.aggregations['my_pivot_facet_field']
+
+      expect(field).to be_a_kind_of Blacklight::SolrResponse::Facets::FacetField
+
+      expect(field.name).to eq 'my_pivot_facet_field'
+
+      expect(field.items.size).to eq 1
+
+      expect(field.items.first).to respond_to(:items)
+
+      expect(field.items.first.items.size).to eq 1
+      expect(field.items.first.items.first.fq).to eq({ 'field_a' => 'a' })
+    end
+  end
+
 end