blacklight 5.15.0 → 5.16.0

data/spec/controllers/saved_searches_controller_spec.rb

@@ -26,7 +26,7 @@ describe SavedSearchesController do
       session[:history] = [@one.id]
       expect {
         post :save, :id => @two.id
-      }.to raise_exception
+      }.to raise_error ActiveRecord::RecordNotFound
     end
 
   end

data/spec/helpers/facets_helper_spec.rb

@@ -224,8 +224,8 @@ describe FacetsHelper do
   end
 
   describe "render_facet_limit_list" do
-    let(:f1) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '792', value: 'Book') }
-    let(:f2) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
+    let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
+    let(:f2) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
     let(:paginator) { Blacklight::Solr::FacetPaginator.new([f1, f2], limit: 10) }
     subject { helper.render_facet_limit_list(paginator, 'type_solr_field') }
     before do

data/spec/helpers/search_history_constraints_helper_spec.rb

@@ -8,6 +8,10 @@ describe SearchHistoryConstraintsHelper do
 
       config.add_facet_field 'some_facet', :label => 'Some'
       config.add_facet_field 'other_facet', :label => 'Other'
+      config.add_facet_field 'i18n_facet'
+
+      I18n.backend.store_translations(:en, blacklight: {search: {fields: {facet: {i18n_facet: 'English facet label'}}}})
+      I18n.backend.store_translations(:de, blacklight: {search: {fields: {facet: {i18n_facet: 'German facet label'}}}})
     end
   end
 
@@ -75,11 +79,27 @@ describe SearchHistoryConstraintsHelper do
 
       it "should render a constraint for a selected facet not in the config" do
         response = helper.render_search_to_s_filters(:f => {"undefined_facet" => ["value1", "value2"]})
-        expect(response).to eq("<span class=\"constraint\"><span class=\"filterName\">Undefined Facet:</span><span class=\"filterValues\"><span class=\"filterValue\">value1</span><span class=\"filterSeparator\"> and </span><span class=\"filterValue\">value2</span></span></span>")
+        expect(response).to eq("<span class=\"constraint\"><span class=\"filterName\">#{'undefined_facet'.humanize}:</span><span class=\"filterValues\"><span class=\"filterValue\">value1</span><span class=\"filterSeparator\"> and </span><span class=\"filterValue\">value2</span></span></span>")
       end
-    end
 
-  
+      context 'with I18n translations for selected facet' do
+        before do
+          @orig_locale = I18n.locale
+        end
+
+        after do
+          I18n.locale = @orig_locale
+        end
+
+        it 'should render the correct I18n label for a selected facet with I18n translations' do
+          {en: 'English facet label', de: 'German facet label'}.each do |locale, label|
+            I18n.locale = locale
+            response = helper.render_search_to_s_filters(f: {'i18n_facet' => ['value1', 'value2']})
+            expect(response).to include(label)
+          end
+        end
+      end
+    end
   end
 
 end

data/spec/lib/blacklight_spec.rb

@@ -11,5 +11,4 @@ describe Blacklight do
     end
 
   end
-  
 end

data/spec/{lib → models}/blacklight/configuration_spec.rb

@@ -119,7 +119,7 @@ describe "Blacklight::Configuration" do
       it "should return default classes" do
         config_copy = @config.inheritable_copy
 
-        expect(config_copy.response_model).to eq Blacklight::SolrResponse
+        expect(config_copy.response_model).to eq Blacklight::Solr::Response
         expect(config_copy.document_model).to eq SolrDocument
       end
     end

data/spec/{lib → models}/blacklight/facet_paginator_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 describe Blacklight::FacetPaginator do
 
-  let(:f1) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '792', value: 'Book') }
-  let(:f2) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
-  let(:f3) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '58', value: 'Serial') }
-  let(:f4) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '48', value: 'Musical Recording') }
-  let(:f5) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '37', value: 'Microform') }
-  let(:f6) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '27', value: 'Thesis') }
-  let(:f7) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '0') }
+  let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
+  let(:f2) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '65', value: 'Musical Score') }
+  let(:f3) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '58', value: 'Serial') }
+  let(:f4) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '48', value: 'Musical Recording') }
+  let(:f5) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '37', value: 'Microform') }
+  let(:f6) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '27', value: 'Thesis') }
+  let(:f7) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '0') }
   let(:seven_facet_values) { [f1, f2, f3, f4, f5, f6, f7] }
   let(:six_facet_values) { [f1, f2, f3, f4, f5, f6] }
   let(:limit) { 6 }

data/spec/{lib → models}/blacklight/solr/facet_paginator_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Blacklight::Solr::FacetPaginator do
-  let(:f1) { Blacklight::SolrResponse::Facets::FacetItem.new(hits: '792', value: 'Book') }
+  let(:f1) { Blacklight::Solr::Response::Facets::FacetItem.new(hits: '792', value: 'Book') }
   describe "#as_json" do
     subject { described_class.new([f1], offset: 0, limit: nil).as_json }
     it "should be well structured" do

data/spec/{lib/blacklight/solr_repository_spec.rb → models/blacklight/solr/repository_spec.rb}

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Blacklight::SolrRepository do
+describe Blacklight::Solr::Repository do
 
   let :blacklight_config do
     CatalogController.blacklight_config.deep_copy
   end
 
   subject do
-    Blacklight::SolrRepository.new blacklight_config
+    Blacklight::Solr::Repository.new blacklight_config
   end
 
   let :mock_response do
@@ -23,38 +23,38 @@ describe Blacklight::SolrRepository do
       blacklight_config.document_solr_path = 'abc'
       blacklight_config.solr_path = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('abc', anything).and_return(mock_response)
-      expect(subject.find("123")).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.find("123")).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should use the default solr path" do
       blacklight_config.solr_path = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('xyz', anything).and_return(mock_response)
-      expect(subject.find("123")).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.find("123")).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should use a default :qt param" do
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { id: '123', qt: 'document'})).and_return(mock_response)
-      expect(subject.find("123", {})).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.find("123", {})).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should use the provided :qt param" do
       blacklight_config.document_solr_request_handler = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { id: '123', qt: 'abc'})).and_return(mock_response)
-      expect(subject.find("123", {qt: 'abc'})).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.find("123", {qt: 'abc'})).to be_a_kind_of Blacklight::Solr::Response
     end
     
     it "should use the :qt parameter from the default_document_solr_params" do
       blacklight_config.default_document_solr_params[:qt] = 'abc'
       blacklight_config.document_solr_request_handler = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { id: '123', qt: 'abc'})).and_return(mock_response)
-      expect(subject.find("123")).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.find("123")).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should preserve the class of the incoming params" do
       doc_params = HashWithIndifferentAccess.new
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
       response = subject.find("123", doc_params)
-      expect(response).to be_a_kind_of Blacklight::SolrResponse
+      expect(response).to be_a_kind_of Blacklight::Solr::Response
       expect(response.params).to be_a_kind_of HashWithIndifferentAccess
     end
   end
@@ -63,24 +63,24 @@ describe Blacklight::SolrRepository do
     it "should use the search-specific solr path" do
       blacklight_config.solr_path = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('xyz', anything).and_return(mock_response)
-      expect(subject.search({})).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.search({})).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should use the default solr path" do
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
-      expect(subject.search({})).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.search({})).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should use a default :qt param" do
       blacklight_config.qt = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { qt: 'xyz'})).and_return(mock_response)
-      expect(subject.search({})).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.search({})).to be_a_kind_of Blacklight::Solr::Response
     end
 
     it "should use the provided :qt param" do
       blacklight_config.qt = 'xyz'
       allow(subject.connection).to receive(:send_and_receive).with('select', hash_including(params: { qt: 'abc'})).and_return(mock_response)
-      expect(subject.search({qt: 'abc'})).to be_a_kind_of Blacklight::SolrResponse
+      expect(subject.search({qt: 'abc'})).to be_a_kind_of Blacklight::Solr::Response
     end
     
     it "should preserve the class of the incoming params" do
@@ -89,7 +89,7 @@ describe Blacklight::SolrRepository do
       allow(subject.connection).to receive(:send_and_receive).with('select', anything).and_return(mock_response)
       
       response = subject.search(search_params)
-      expect(response).to be_a_kind_of Blacklight::SolrResponse
+      expect(response).to be_a_kind_of Blacklight::Solr::Response
       expect(response.params).to be_a_kind_of HashWithIndifferentAccess
     end
   end

data/spec/{lib/blacklight/solr_response → models/blacklight/solr/response}/facets_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Blacklight::SolrResponse::Facets do
-  describe Blacklight::SolrResponse::Facets::FacetField do
+describe Blacklight::Solr::Response::Facets do
+  describe Blacklight::Solr::Response::Facets::FacetField do
 
     describe "A field with default options" do
-      subject { Blacklight::SolrResponse::Facets::FacetField.new "my_field", [] }
+      subject { Blacklight::Solr::Response::Facets::FacetField.new "my_field", [] }
 
       its(:name) { should eq "my_field" }
       its(:limit) { should eq 100 }
@@ -13,7 +13,7 @@ describe Blacklight::SolrResponse::Facets do
     end
 
     describe "A field with additional options" do
-      subject { Blacklight::SolrResponse::Facets::FacetField.new "my_field", [], limit: 15, sort: 'alpha', offset: 23 }
+      subject { Blacklight::Solr::Response::Facets::FacetField.new "my_field", [], limit: 15, sort: 'alpha', offset: 23 }
 
       its(:name) { should eq "my_field" }
       its(:limit) { should eq 15 }
@@ -23,7 +23,7 @@ describe Blacklight::SolrResponse::Facets do
   end
 
   describe "#facets" do
-    subject { Blacklight::SolrResponse.new({}, {}) }
+    subject { Blacklight::Solr::Response.new({}, {}) }
     let(:aggregations) { { x: 1, y: 2 } } 
     it "should get the aggregation values" do
       allow(subject).to receive(:aggregations).and_return aggregations
@@ -35,7 +35,7 @@ describe Blacklight::SolrResponse::Facets do
   end
 
   describe "#facet_by_field_name" do
-    subject { Blacklight::SolrResponse.new({}, {}) }
+    subject { Blacklight::Solr::Response.new({}, {}) }
     let(:aggregations) { { x: double } } 
 
     it "should pull facets out of the aggregations" do
@@ -51,7 +51,7 @@ describe Blacklight::SolrResponse::Facets do
     let(:facet_field) { ['my_field', []] }
     let(:response_header) { { params: request_params }}
     let(:request_params) { Hash.new }
-    subject { Blacklight::SolrResponse.new({responseHeader: response_header, facet_counts: { facet_fields: [facet_field] }}.with_indifferent_access, request_params)  }
+    subject { Blacklight::Solr::Response.new({responseHeader: response_header, facet_counts: { facet_fields: [facet_field] }}.with_indifferent_access, request_params)  }
 
     describe "#limit" do
       it "should extract a field-specific limit value" do
@@ -121,7 +121,7 @@ describe Blacklight::SolrResponse::Facets do
       }
     end
     
-    subject { Blacklight::SolrResponse.new(response, {}) }
+    subject { Blacklight::Solr::Response.new(response, {}) }
 
     it "should mark the facet.missing field with a human-readable label and fq" do
       missing = subject.aggregations["some_field"].items.find { |i| i.value.nil? }
@@ -158,12 +158,12 @@ describe Blacklight::SolrResponse::Facets do
       }
     end
 
-    subject { Blacklight::SolrResponse.new(response, {}, blacklight_config: blacklight_config) }
+    subject { Blacklight::Solr::Response.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).to be_a_kind_of Blacklight::Solr::Response::Facets::FacetField
 
       expect(field.name).to eq'my_query_facet_field'
       expect(field.items.size).to eq 2
@@ -200,12 +200,12 @@ describe Blacklight::SolrResponse::Facets do
       }
     end
 
-    subject { Blacklight::SolrResponse.new(response, {}, blacklight_config: blacklight_config) }
+    subject { Blacklight::Solr::Response.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).to be_a_kind_of Blacklight::Solr::Response::Facets::FacetField
 
       expect(field.name).to eq 'my_pivot_facet_field'
 

data/spec/{lib/blacklight/solr_response → models/blacklight/solr/response}/group_response_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Blacklight::SolrResponse::GroupResponse do
+describe Blacklight::Solr::Response::GroupResponse do
   
   let(:response) do
     create_response(sample_response)
@@ -16,7 +16,7 @@ describe Blacklight::SolrResponse::GroupResponse do
 
       expect(group.groups).to have(2).items
       group.groups.each do |group|
-        expect(group).to be_a Blacklight::SolrResponse::Group
+        expect(group).to be_a Blacklight::Solr::Response::Group
       end
     end
     it "should include a list of SolrDocuments" do
@@ -61,7 +61,7 @@ describe Blacklight::SolrResponse::GroupResponse do
 end
 
 def create_response(response, params = {})
-  Blacklight::SolrResponse.new(response, params)
+  Blacklight::Solr::Response.new(response, params)
 end
 
 def sample_response

data/spec/{lib/blacklight/solr_response → models/blacklight/solr/response}/group_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Blacklight::SolrResponse::Group do
+describe Blacklight::Solr::Response::Group do
   
   let(:response) do
     create_response(sample_response)
@@ -53,7 +53,7 @@ describe Blacklight::SolrResponse::Group do
 end
 
 def create_response(response, params = {})
-  Blacklight::SolrResponse.new(response, params)
+  Blacklight::Solr::Response.new(response, params)
 end
 
 def sample_response

data/spec/{lib/blacklight/solr_response_spec.rb → models/blacklight/solr/response_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Blacklight::SolrResponse do
+describe Blacklight::Solr::Response do
 
   def create_response
     raw_response = eval(mock_query_response)
-    Blacklight::SolrResponse.new(raw_response, raw_response['params'])
+    Blacklight::Solr::Response.new(raw_response, raw_response['params'])
   end
 
   let(:r) { create_response }
@@ -24,7 +24,7 @@ describe Blacklight::SolrResponse do
     expect(r.docs).to have(11).docs
     expect(r.params[:echoParams]).to eq 'EXPLICIT'
     
-    expect(r).to be_a(Blacklight::SolrResponse::Facets)
+    expect(r).to be_a(Blacklight::Solr::Response::Facets)
   end
 
   it 'should provide facet helpers' do
@@ -72,20 +72,20 @@ describe Blacklight::SolrResponse do
 
   describe "FacetItem" do
     it "should work with a field,value tuple" do
-      item = Blacklight::SolrResponse::Facets::FacetItem.new('value', 15)
+      item = Blacklight::Solr::Response::Facets::FacetItem.new('value', 15)
       expect(item.value).to eq 'value'
       expect(item.hits).to eq 15
     end
 
     it "should work with a field,value + hash triple" do
-      item = Blacklight::SolrResponse::Facets::FacetItem.new('value', 15, :a => 1, :value => 'ignored')
+      item = Blacklight::Solr::Response::Facets::FacetItem.new('value', 15, :a => 1, :value => 'ignored')
       expect(item.value).to eq 'value'
       expect(item.hits).to eq 15
       expect(item.a).to eq 1
     end
 
     it "should work like an openstruct" do
-      item = Blacklight::SolrResponse::Facets::FacetItem.new(:value => 'value', :hits => 15)
+      item = Blacklight::Solr::Response::Facets::FacetItem.new(:value => 'value', :hits => 15)
       
       expect(item.hits).to eq 15
       expect(item.value).to eq 'value'
@@ -93,12 +93,12 @@ describe Blacklight::SolrResponse do
     end
 
     it "should provide a label accessor" do
-      item = Blacklight::SolrResponse::Facets::FacetItem.new('value', :hits => 15)
+      item = Blacklight::Solr::Response::Facets::FacetItem.new('value', :hits => 15)
       expect(item.label).to eq 'value'
     end
 
     it "should use a provided label" do
-      item = Blacklight::SolrResponse::Facets::FacetItem.new('value', 15, :label => 'custom label')
+      item = Blacklight::Solr::Response::Facets::FacetItem.new('value', 15, :label => 'custom label')
       expect(item.label).to eq 'custom label'
 
     end
@@ -114,13 +114,13 @@ describe Blacklight::SolrResponse do
   it 'should provide the responseHeader params' do
     raw_response = eval(mock_query_response)
     raw_response['responseHeader']['params']['test'] = :test
-    r = Blacklight::SolrResponse.new(raw_response, raw_response['params'])
+    r = Blacklight::Solr::Response.new(raw_response, raw_response['params'])
     expect(r.params['test']).to eq :test
   end
 
   it 'should provide the solr-returned params and "rows" should be 11' do
     raw_response = eval(mock_query_response)
-    r = Blacklight::SolrResponse.new(raw_response, {})
+    r = Blacklight::Solr::Response.new(raw_response, {})
     expect(r.params[:rows].to_s).to eq '11'
     expect(r.params[:sort]).to eq 'title_sort asc, pub_date_sort desc'
   end
@@ -128,42 +128,42 @@ describe Blacklight::SolrResponse do
   it 'should provide the ruby request params if responseHeader["params"] does not exist' do
     raw_response = eval(mock_query_response)
     raw_response.delete 'responseHeader'
-    r = Blacklight::SolrResponse.new(raw_response, :rows => 999, :sort => 'score desc, pub_date_sort desc, title_sort asc')
+    r = Blacklight::Solr::Response.new(raw_response, :rows => 999, :sort => 'score desc, pub_date_sort desc, title_sort asc')
     expect(r.params[:rows].to_s).to eq '999'
     expect(r.params[:sort]).to eq 'score desc, pub_date_sort desc, title_sort asc'
   end
 
   it 'should provide spelling suggestions for regular spellcheck results' do
     raw_response = eval(mock_response_with_spellcheck)
-    r = Blacklight::SolrResponse.new(raw_response,  {})
+    r = Blacklight::Solr::Response.new(raw_response,  {})
     expect(r.spelling.words).to include("dell")
     expect(r.spelling.words).to include("ultrasharp")
   end
 
   it 'should provide spelling suggestions for extended spellcheck results' do
     raw_response = eval(mock_response_with_spellcheck_extended)
-    r = Blacklight::SolrResponse.new(raw_response, {})
+    r = Blacklight::Solr::Response.new(raw_response, {})
     expect(r.spelling.words).to include("dell")
     expect(r.spelling.words).to include("ultrasharp")
   end
 
   it 'should provide no spelling suggestions when extended results and suggestion frequency is the same as original query frequency' do
     raw_response = eval(mock_response_with_spellcheck_same_frequency)
-    r = Blacklight::SolrResponse.new(raw_response, {})
+    r = Blacklight::Solr::Response.new(raw_response, {})
     expect(r.spelling.words).to eq []
   end
 
   context "pre solr 5 spellcheck collation syntax" do
     it 'should provide spelling suggestions for a regular spellcheck results with a collation' do
       raw_response = eval(mock_response_with_spellcheck_collation)
-      r = Blacklight::SolrResponse.new(raw_response, {})
+      r = Blacklight::Solr::Response.new(raw_response, {})
       expect(r.spelling.words).to include("dell")
       expect(r.spelling.words).to include("ultrasharp")
     end
 
     it 'should provide spelling suggestion collation' do
       raw_response = eval(mock_response_with_spellcheck_collation)
-      r = Blacklight::SolrResponse.new(raw_response, {})
+      r = Blacklight::Solr::Response.new(raw_response, {})
       expect(r.spelling.collation).to eq 'dell ultrasharp'
     end
   end
@@ -171,33 +171,33 @@ describe Blacklight::SolrResponse do
   context "solr 5 spellcheck collation syntax" do
     it 'should provide spelling suggestions for a regular spellcheck results with a collation' do
       raw_response = eval(mock_response_with_spellcheck_collation_solr5)
-      r = Blacklight::SolrResponse.new(raw_response, {})
+      r = Blacklight::Solr::Response.new(raw_response, {})
       expect(r.spelling.words).to include("dell")
       expect(r.spelling.words).to include("ultrasharp")
     end
 
     it 'should provide spelling suggestion collation' do
       raw_response = eval(mock_response_with_spellcheck_collation_solr5)
-      r = Blacklight::SolrResponse.new(raw_response, {})
+      r = Blacklight::Solr::Response.new(raw_response, {})
       expect(r.spelling.collation).to eq 'dell ultrasharp'
     end
   end
 
   it "should provide MoreLikeThis suggestions" do
     raw_response = eval(mock_response_with_more_like_this)
-    r = Blacklight::SolrResponse.new(raw_response, {})
+    r = Blacklight::Solr::Response.new(raw_response, {})
     expect(r.more_like(double(:id => '79930185'))).to have(2).items
   end
 
   it "should be empty when the response has no results" do
-    r = Blacklight::SolrResponse.new({}, {})
+    r = Blacklight::Solr::Response.new({}, {})
     allow(r).to receive_messages(:total => 0)
     expect(r).to be_empty
   end
   
   describe "#export_formats" do
     it "should collect the unique export formats for the current response" do
-      r = Blacklight::SolrResponse.new({}, {})
+      r = Blacklight::Solr::Response.new({}, {})
       allow(r).to receive_messages(documents: [double(:export_formats => { a: 1, b: 2}), double(:export_formats => { b: 1, c: 2})])
       expect(r.export_formats).to include :a, :b 
     end