blacklight 5.19.2 → 6.0.0.pre1

data/spec/lib/blacklight/parameters_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Blacklight::Parameters do
+  describe "sanitize_search_params" do
+    subject { described_class.sanitize(params) }
+
+    context "with nil values" do
+      let(:params) { { a: nil, b: 1 } }
+      it "removes them" do
+        expect(subject).to_not have_key(:a)
+        expect(subject[:b]).to eq 1
+      end
+    end
+
+    context "with blacklisted keys" do
+      let(:params) { { action: true, controller: true, id: true, commit: true, utf8: true } }
+      it "removes them" do
+        expect(subject).to be_empty
+      end
+    end
+  end
+end

data/spec/lib/blacklight/path_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+
+describe Blacklight::Path do
+  let(:blacklight_config) do
+    Blacklight::Configuration.new.configure do |config|
+      config.index.title_field = 'title_display'
+      config.index.display_type_field = 'format'
+    end
+  end
+
+  let(:helper) { described_class.new(params, blacklight_config) }
+  let(:params) { {} }
+
+  describe "params_for_search" do
+    let(:params) { { 'default' => 'params' } }
+
+    it "takes original params" do
+      result = helper.params_for_search
+      expect(result).to eq({ 'default' => 'params' })
+      expect(params.object_id).to_not eq result.object_id
+    end
+
+    it "accepts params to merge into the controller's params" do
+      result = helper.params_for_search(q: 'query')
+      expect(result).to include(:q => 'query', 'default' => 'params')
+    end
+
+    context "when params have blacklisted keys" do
+      let(:params) { { action: 'action', controller: 'controller', id: "id", commit: 'commit' } }
+      it "removes them" do
+        result = helper.params_for_search
+        expect(result.keys).to_not include(:action, :controller, :commit, :id)
+      end
+    end
+
+    context "when params has page" do
+      context "and per_page changed" do
+        let(:params) { { per_page: 20, page: 5 } }
+        it "adjusts the current page" do
+          result = helper.params_for_search(per_page: 100)
+          expect(result[:page]).to eq 1
+        end
+      end
+
+      context "and per_page didn't change" do
+        let(:params) { { per_page: 20, page: 5 } }
+        it "doesn't change the current page" do
+          result = helper.params_for_search(per_page: 20)
+          expect(result[:page]).to eq 5
+        end
+      end
+
+      context "and the sort changes" do
+        let(:params) { { sort: 'field_a', page: 5 } }
+        it "adjusts the current page" do
+          result = helper.params_for_search(sort: 'field_b')
+          expect(result[:page]).to eq 1
+        end
+      end
+
+      context "and the sort didn't change" do
+        let(:params) { { sort: 'field_a', page: 5 } }
+        it "doesn't change the current page" do
+          result = helper.params_for_search(sort: 'field_a')
+          expect(result[:page]).to eq 5
+        end
+      end
+    end
+
+    context "with a block" do
+      let(:params) { { a: 1, b: 2 } }
+      it "should evalute the block and allow it to add or remove keys" do
+        result = helper.params_for_search(c: 3) do |params|
+          params.except! :a, :b
+          params[:d] = 'd'
+        end
+
+        expect(result.keys).to_not include(:a, :b)
+        expect(result[:c]).to eq 3
+        expect(result[:d]).to eq 'd'
+      end
+    end
+  end
+
+  describe "add_facet_params" do
+    let(:params_no_existing_facet) { { q: "query", search_field: "search_field", per_page: "50" } }
+    let(:params_existing_facets) { { q: "query", search_field: "search_field", per_page: "50", f: { "facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"] } } }
+
+    context "when there are no pre-existing facets" do
+      let(:params) { params_no_existing_facet }
+      it "adds facet value" do
+        result_params = helper.add_facet_params("facet_field", "facet_value")
+        expect(result_params[:f]).to be_a_kind_of(Hash)
+        expect(result_params[:f]["facet_field"]).to be_a_kind_of(Array)
+        expect(result_params[:f]["facet_field"]).to eq ["facet_value"]
+      end
+
+      it "leaves non-facet params alone" do
+        result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
+
+        params.each_pair do |key, value|
+          next if key == :f
+          expect(result_params[key]).to eq params[key]
+        end
+      end
+
+      it "uses the facet's key in the url" do
+        allow(helper).to receive(:facet_configuration_for_field).with('some_field').and_return(double(single: true, field: "a_solr_field", key: "some_key"))
+
+        result_params = helper.add_facet_params('some_field', 'my_value')
+
+        expect(result_params[:f]['some_key']).to have(1).item
+        expect(result_params[:f]['some_key'].first).to eq 'my_value'
+      end
+    end
+
+    context "when there are pre-existing facets" do
+      let(:params) { params_existing_facets }
+      it "adds a facet param to existing facet constraints" do
+        result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
+
+        expect(result_params[:f]).to be_a_kind_of(Hash)
+
+        params_existing_facets[:f].each_pair do |facet_field, value_list|
+          expect(result_params[:f][facet_field]).to be_a_kind_of(Array)
+          if facet_field == 'facet_field_2'
+            expect(result_params[:f][facet_field]).to eq (params_existing_facets[:f][facet_field] | ["new_facet_value"])
+          else
+            expect(result_params[:f][facet_field]).to eq params_existing_facets[:f][facet_field]
+          end
+        end
+      end
+
+      it "leaves non-facet params alone" do
+        result_params = helper.add_facet_params("facet_field_2", "new_facet_value")
+
+        params.each_pair do |key, value|
+          next if key == :f
+          expect(result_params[key]).to eq params[key]
+        end
+      end
+    end
+
+    context "with a facet selected in the params" do
+      let(:params) { { f: { 'single_value_facet_field' => 'other_value' } } }
+      it "replaces facets configured as single" do
+        allow(helper).to receive(:facet_configuration_for_field).with('single_value_facet_field').and_return(double(single: true, key: "single_value_facet_field"))
+        result_params = helper.add_facet_params('single_value_facet_field', 'my_value')
+
+        expect(result_params[:f]['single_value_facet_field']).to have(1).item
+        expect(result_params[:f]['single_value_facet_field'].first).to eq 'my_value'
+      end
+    end
+
+    it "accepts a FacetItem instead of a plain facet value" do
+      result_params = helper.add_facet_params('facet_field_1', double(value: 123))
+
+      expect(result_params[:f]['facet_field_1']).to include(123)
+    end
+
+    it "defers to the field set on a FacetItem" do
+      result_params = helper.add_facet_params('facet_field_1', double(:field => 'facet_field_2', :value => 123))
+
+      expect(result_params[:f]['facet_field_1']).to be_blank
+      expect(result_params[:f]['facet_field_2']).to include(123)
+    end
+
+    it "should add any extra fq parameters from the FacetItem" do
+      result_params = helper.add_facet_params('facet_field_1', double(:value => 123, fq: { 'facet_field_2' => 'abc' }))
+
+      expect(result_params[:f]['facet_field_1']).to include(123)
+      expect(result_params[:f]['facet_field_2']).to include('abc')
+    end
+  end
+
+  describe "add_facet_params_and_redirect" do
+    let(:params) { { q: "query",
+                :search_field => "search_field",
+                :per_page => "50",
+                :page => "5",
+                :f => {"facet_field_1" => ["value1"], "facet_field_2" => ["value2", "value2a"]},
+                Blacklight::Solr::FacetPaginator.request_keys[:page] => "100",
+                Blacklight::Solr::FacetPaginator.request_keys[:sort] => "index",
+                :id => 'facet_field_name'
+      }
+    }
+
+    it "does not include request parameters used by the facet paginator" do
+      params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
+
+      bad_keys = Blacklight::Solr::FacetPaginator.request_keys.values + [:id]
+      bad_keys.each do |paginator_key|
+        expect(params.keys).to_not include(paginator_key)
+      end
+    end
+
+    it 'removes :page request key' do
+      params = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
+      expect(params.keys).to_not include(:page)
+    end
+
+    it "should otherwise do the same thing as add_facet_params" do
+      added_facet_params = helper.add_facet_params("facet_field_2", "facet_value")
+      added_facet_params_from_facet_action = helper.add_facet_params_and_redirect("facet_field_2", "facet_value")
+
+      expect(added_facet_params_from_facet_action).to eq added_facet_params.except(Blacklight::Solr::FacetPaginator.request_keys[:page], Blacklight::Solr::FacetPaginator.request_keys[:sort])
+    end
+  end
+
+  describe "#remove_facet_params" do
+    let(:params) { { f: facet_params }}
+    let(:facet_params) { { } }
+    context "when the facet has multiple values" do
+      let(:facet_params) { { 'some_field' => ['some_value', 'another_value'] } }
+
+      it "removes the facet / value tuple from the query parameters" do
+        params = helper.remove_facet_params('some_field', 'some_value')
+        expect(params[:f]['some_field']).not_to include 'some_value'
+        expect(params[:f]['some_field']).to include 'another_value'
+      end
+    end
+
+    context "when the facet has configuration" do
+      before do
+        allow(helper).to receive(:facet_configuration_for_field).with('some_field').and_return(
+          double(single: true, field: "a_solr_field", key: "some_key"))
+      end
+      let(:facet_params) { { 'some_key' => ['some_value', 'another_value'] } }
+
+      it "uses the facet's key configuration" do
+        params = helper.remove_facet_params('some_field', 'some_value')
+        expect(params[:f]['some_key']).not_to eq 'some_value'
+        expect(params[:f]['some_key']).to include 'another_value'
+      end
+    end
+
+    it "should remove the facet entirely when the last facet value is removed" do
+      facet_params['another_field'] = ['some_value']
+      facet_params['some_field'] = ['some_value']
+
+      params = helper.remove_facet_params('some_field', 'some_value')
+
+      expect(params[:f]).not_to include 'some_field'
+    end
+
+    it "should remove the 'f' parameter entirely when no facets remain" do
+      facet_params['some_field'] = ['some_value']
+
+      params = helper.remove_facet_params('some_field', 'some_value')
+
+      expect(params).not_to include :f
+    end
+  end
+end

data/spec/lib/blacklight_spec.rb

@@ -1,12 +1,15 @@
 require 'spec_helper'
 
 describe Blacklight do
+  
   context 'root' do
+
     let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..' )) }
 
     it 'should return the full path to the BL plugin' do
       expect(Blacklight.root).to eq blroot
     end
+
   end
 
   describe '.default_index' do
@@ -15,7 +18,7 @@ describe Blacklight do
         allow(Blacklight).to receive(:connection_config).and_return(adapter: 'solr')
       end
 
-      it 'is an instance of Blacklight::SolrRepository' do
+      it 'is an instance of Blacklight::Solr::Repository' do
         expect(Blacklight.default_index).to be_a Blacklight::Solr::Repository
       end
     end
@@ -38,7 +41,7 @@ describe Blacklight do
         allow(Blacklight).to receive(:connection_config).and_return(adapter: 'elastic_search')
       end
 
-      it 'resolves to the ElasticSearch::Repository implementation' do
+      it 'resolves to the SolrRepository implementation' do
         expect(Blacklight.repository_class).to eq Blacklight::ElasticSearch::Repository
       end
     end
@@ -60,4 +63,5 @@ describe Blacklight do
       expect(Blacklight.default_configuration).to be_a Blacklight::Configuration
     end
   end
+  
 end

data/spec/models/blacklight/configuration/context_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Blacklight::Configuration::Context do
+
+  subject { described_class.new(context) }
+  let(:context) { double }
+
+  describe "#evaluate_configuration_conditional" do
+    it "should pass through regular values" do
+      val = double
+      expect(subject.evaluate_configuration_conditional(val)).to eq val
+    end
+
+    it "should execute a helper method" do
+      allow(context).to receive_messages(:my_check => true)
+      expect(subject.evaluate_configuration_conditional(:my_check)).to be true
+    end
+
+    it "should call a helper to determine if it should render a field" do
+      a = double
+      allow(context).to receive(:my_check_with_an_arg).with(a).and_return(true)
+      expect(subject.evaluate_configuration_conditional(:my_check_with_an_arg, a)).to be true
+    end
+
+    it "should evaluate a Proc to determine if it should render a field" do
+      one_arg_lambda = lambda { |context, a| true }
+      two_arg_lambda = lambda { |context, a, b| true }
+      expect(subject.evaluate_configuration_conditional(one_arg_lambda, 1)).to be true
+      expect(subject.evaluate_configuration_conditional(two_arg_lambda, 1, 2)).to be true
+    end
+  end
+
+end

data/spec/models/blacklight/document/active_model_shim_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe 'Blacklight::Document::ActiveModelShim' do
+
+  class MockDocument
+    include Blacklight::Document
+    include Blacklight::Document::ActiveModelShim
+  end
+
+  class MockResponse
+    attr_reader :response, :params
+
+    def initialize(response, params)
+      @response = response
+      @params = params
+    end
+
+    def documents
+      response.collect {|doc| MockDocument.new(doc, self)}
+    end
+  end
+
+  before do
+    allow(MockDocument.repository).to receive(:find).and_return(MockResponse.new([{id: 1}], {}))
+  end
+ 
+  describe "#find" do
+   it "should return a document from the repository" do
+      expect(MockDocument.find(1)).to be_a MockDocument
+      expect(MockDocument.find(1).id).to be 1
+    end
+  end
+end

data/spec/models/blacklight/document_spec.rb

@@ -59,4 +59,32 @@ describe Blacklight::Document do
       end
     end
   end
-end
+
+  describe "#to_global_id" do
+    class MockDocument
+      include Blacklight::Document
+      include Blacklight::Document::ActiveModelShim
+    end
+
+    class MockResponse
+      attr_reader :response, :params
+
+      def initialize(response, params)
+        @response = response
+        @params = params
+      end
+
+      def documents
+        response.collect {|doc| MockDocument.new(doc, self)}
+      end
+    end
+
+    before do
+      allow(MockDocument.repository).to receive(:find).and_return(MockResponse.new([{id: 1}], {}))
+    end
+
+    it "should have a globalid" do
+      expect(MockDocument.find(1).to_global_id).to be_a GlobalID
+    end
+  end
+end

data/spec/models/blacklight/facet_paginator_spec.rb

@@ -68,25 +68,26 @@ describe Blacklight::FacetPaginator do
         expect(click_params[ sort_key ]).to eq 'count'
         expect(click_params[ page_key ]).to be_nil
     end
-  end
 
-  context "for a nil :limit" do
-    let(:paginator) { described_class.new(seven_facet_values, offset: 0, limit: nil) }
+    context 'when sorting by "count"' do
+      subject { described_class.new([]) }
 
-    describe "#items" do
-      subject { paginator.items }
-      it { is_expected.to eq seven_facet_values }
-    end
+      it 'includes the prefix filter for "index" sorting' do
+        expect(subject.params_for_resort_url('index', :'facet.prefix' => 'A')).to include :'facet.prefix' => 'A'
+      end
 
-    describe "#last_page?" do
-      subject { paginator.last_page? }
-      it { is_expected.to be true }
+      it 'removes the prefix filter' do
+        expect(subject.params_for_resort_url('count', :'facet.prefix' => 'A')).not_to include :'facet.prefix' => 'A'
+      end
     end
+  end
 
-    describe "#current_page" do
-      subject { paginator.current_page }
-      it { is_expected.to eq 1 }
+  context "for a nil :limit" do
+    subject { described_class.new(seven_facet_values, offset: 0, limit: nil) }
+    it "should return all the items" do
+      expect(subject.items).to eq seven_facet_values
     end
+    it { should be_last_page }
   end
 
   describe "#as_json" do