blacklight 6.24.0 → 7.0.0.rc1

data/spec/integration/generators/blacklight/{solr5_generator_spec.rb → solr_generator_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
-require 'generators/blacklight/solr5_generator'
+require 'generators/blacklight/solr_generator'
 
-describe Blacklight::Solr5Generator do
+RSpec.describe Blacklight::SolrGenerator do
   let(:destination) { Dir.mktmpdir }
 
   describe "#solr_wrapper_config" do
@@ -57,4 +57,4 @@ describe Blacklight::Solr5Generator do
       end
     end
   end
-end
+end

data/spec/lib/blacklight/configuration/facet_field_spec.rb

@@ -0,0 +1,11 @@
+RSpec.describe Blacklight::Configuration::FacetField do
+  describe 'link_to_search' do
+    subject { described_class.new(link_to_search: true) }
+
+    it 'is deprecated' do
+      expect(Deprecation).to receive(:warn)
+      expect(subject.normalize!)
+      expect(subject.link_to_facet).to eq true
+    end
+  end
+end

data/spec/lib/blacklight/configuration/field_spec.rb

@@ -0,0 +1,12 @@
+RSpec.describe Blacklight::Configuration::Field do
+  subject { described_class.new(key: key, label: label) }
+  let(:key) { 'some_key' }
+  let(:label) { 'some label' }
+
+  describe '#display_label' do
+    it "looks up the label to display for the given document and field" do
+      allow(I18n).to receive(:t).with(:"blacklight.search.fields.my_context.some_key", default: [:"blacklight.search.fields.some_key", label, subject.default_label]).and_return('x')
+      expect(subject.display_label('my_context')).to eq 'x'
+    end
+  end
+end

data/spec/lib/blacklight/nested_open_struct_with_hash_access_spec.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::NestedOpenStructWithHashAccess do
+  describe "#deep_dup" do
+    it "preserves the current class" do
+      expect(described_class.new(described_class).deep_dup).to be_a_kind_of described_class
+    end
+
+    it "preserves the default proc" do
+      nested = described_class.new Hash
+
+      copy = nested.deep_dup
+      copy.a[:b] = 1
+      expect(copy.a[:b]).to eq 1
+    end
+  end
+end

data/spec/lib/blacklight/open_struct_with_hash_access_spec.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::OpenStructWithHashAccess do
+  it "provides hash-like accessors for OpenStruct data" do
+    a = described_class.new :foo => :bar, :baz => 1
+
+    expect(a[:foo]).to eq :bar
+    expect(a[:baz]).to eq 1
+    expect(a[:asdf]).to be_nil
+  end
+
+  it "provides hash-like writers for OpenStruct data" do
+    a = described_class.new :foo => :bar, :baz => 1
+
+    a[:asdf] = 'qwerty'
+    expect(a.asdf).to eq 'qwerty'
+
+  end
+
+  it "treats symbols and strings interchangeably in hash access" do
+    h = described_class.new
+
+    h["string"] = "value"
+    expect(h[:string]).to eq "value"
+    expect(h.string).to eq "value"
+
+    h[:symbol] = "value"
+    expect(h["symbol"]).to eq "value"
+    expect(h.symbol).to eq "value"
+  end
+
+  describe "internal hash table" do
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it "exposes the internal hash table" do
+      expect(@h.to_h).to be_a_kind_of(Hash)
+      expect(@h.to_h[:a]).to eq 1
+    end
+
+    it "exposes keys" do
+      expect(@h.keys).to include(:a, :b)
+    end
+
+  end
+
+  describe "#key?" do
+    subject do
+      h = described_class.new
+      h[:a] = 1
+      h[:b] = 2
+      h
+    end
+
+    it "is true if the key exists" do
+      expect(subject.key? :a).to eq true
+    end
+
+    it "is false if the key does not exist" do
+      expect(subject.key? :c).to eq false
+    end
+  end
+
+  describe "#replace" do
+    subject { described_class.new a: 1 }
+
+    it "can use #replace to reorder the hash" do
+      subject.replace b: 1
+      expect(subject.b).to eq 1
+    end
+  end
+
+  describe "#sort_by" do
+    subject { described_class.new c: 3, b:1, a: 2 }
+
+    it "sorts the underlying hash" do
+      sorted = subject.sort_by { |k,v| v }
+      expect(sorted.keys).to match_array [:b, :a, :c]
+    end
+  end
+
+  describe "#sort_by!" do
+    subject { described_class.new c: 3, b:1, a: 2 }
+
+    it "sorts the underlying hash" do
+      subject.sort_by! { |k,v| v }
+      expect(subject.keys).to match_array [:b, :a, :c]
+    end
+  end
+
+  describe "#merge" do
+
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it "merges the object with a hash" do
+      expect(@h.merge(:a => 'a')[:a]).to eq 'a'
+    end
+
+    it "merges the object with another struct" do
+      expect(@h.merge(described_class.new(:a => 'a'))[:a]).to eq 'a'
+    end
+  end
+
+
+  describe "#merge!" do
+
+    before do
+      @h = described_class.new
+      @h[:a] = 1
+      @h[:b] = 2
+    end
+
+    it "merges the object with a hash" do
+      @h.merge!(:a => 'a')
+      expect(@h[:a]).to eq 'a'
+    end
+
+    it "merges the object with another struct" do
+      @h.merge!(described_class.new(:a => 'a'))
+      expect(@h[:a]).to eq 'a'
+    end
+  end
+
+  describe "#to_json" do
+    subject { described_class.new a: 1, b: 2}
+
+    it "serializes as json" do
+      expect(subject.to_json).to eq ({a: 1, b:2}).to_json
+    end
+  end
+
+  describe "#deep_dup" do
+    subject { described_class.new a: 1, b: { c: 1} }
+
+    it "duplicates nested hashes" do
+      copy = subject.deep_dup
+      copy.a = 2
+      copy.b[:c] = 2
+
+      expect(subject.a).to eq 1
+      expect(subject.b[:c]).to eq 1
+      expect(copy.a).to eq 2
+      expect(copy.b[:c]).to eq 2
+    end
+  end
+end

data/spec/lib/blacklight/parameters_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Blacklight::Parameters do
+RSpec.describe Blacklight::Parameters do
   describe "sanitize_search_params" do
     subject { described_class.sanitize(params) }
 

data/spec/lib/blacklight/search_state_spec.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
-describe Blacklight::SearchState do
+RSpec.describe Blacklight::SearchState do
   let(:blacklight_config) do
     Blacklight::Configuration.new.configure do |config|
-      config.index.title_field = 'title_display'
+      config.index.title_field = 'title_tsim'
       config.index.display_type_field = 'format'
     end
   end

data/spec/lib/blacklight_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Blacklight do
+RSpec.describe Blacklight do
   context 'root' do
     let(:blroot) { File.expand_path(File.join(__FILE__, '..', '..', '..' )) }
 

data/spec/lib/tasks/blacklight_task_spec.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 require 'rake'
 
-describe "blacklight:delete_old_searches" do
+RSpec.describe "blacklight:delete_old_searches" do
 
   before do
     @rake = Rake::Application.new      

data/spec/models/blacklight/configurable_spec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Configurable" do
+RSpec.describe "Blacklight::Configurable" do
 
   describe "inheritence" do
     before(:all) do
@@ -17,19 +17,19 @@ describe "Blacklight::Configurable" do
         end
       end
     end
-    it "inherits the configuration when subclassed" do            
+    it "inherits the configuration when subclassed" do
       expect(TestCaseInheritence::Child.blacklight_config.list).to include(1,2,3)
     end
-    
-    it "inherited version should be a deep copy, not original" do      
+
+    it "inherited version should be a deep copy, not original" do
       expect(TestCaseInheritence::Child.blacklight_config).to_not  be(TestCaseInheritence::Parent.blacklight_config)
-    
+
       TestCaseInheritence::Child.blacklight_config.list << "child_only"
 
 
-      expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")      
+      expect(TestCaseInheritence::Child.blacklight_config.list).to include("child_only")
       expect(TestCaseInheritence::Parent.blacklight_config.list).to_not include("child_only")
-    end    
+    end
   end
 
   describe "default configuration" do
@@ -56,15 +56,15 @@ describe "Blacklight::Configurable" do
       a.send(:include, Blacklight::Configurable)
       expect(a.blacklight_config.a).to eq 1
     end
-    
+
     it "has configure_blacklight convenience method" do
       klass = Class.new
       klass.send(:include, Blacklight::Configurable)
-      
+
       klass.configure_blacklight do |config|
         config.my_key = 'value'
-      end 
-      
+      end
+
       expect(klass.blacklight_config.my_key).to eq 'value'
     end
 
@@ -75,11 +75,11 @@ describe "Blacklight::Configurable" do
 
       instance = klass.new
       instance.blacklight_config = Blacklight::Configuration.new
-      
+
       expect(instance.blacklight_config).to_not eq klass.blacklight_config
       expect(instance.blacklight_config.foo).to be_nil
     end
-    
+
     it "allows instance to set it's own config seperate from class" do
       # this is built into class_attribute; we spec it both to document it,
       # and to ensure we preserve this feature if we change implementation
@@ -89,7 +89,7 @@ describe "Blacklight::Configurable" do
       klass.blacklight_config.foo = "bar"
       klass.blacklight_config.bar = []
       klass.blacklight_config.bar << "asd"
-      
+
       instance = klass.new
       instance.blacklight_config.bar << "123"
       expect(instance.blacklight_config).to_not eq klass.blacklight_config
@@ -111,7 +111,6 @@ describe "Blacklight::Configurable" do
       expect(klass.blacklight_config.foo).to eq "bar"
       expect(klass2.blacklight_config.foo).to eq "asdf"
     end
-    
+
   end
 end
-  

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-describe Blacklight::Configuration::Context do
+RSpec.describe Blacklight::Configuration::Context do
 
   subject { described_class.new(context) }
   let(:context) { double }

data/spec/models/blacklight/configuration_spec.rb

@@ -1,23 +1,21 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Configuration" do
+RSpec.describe "Blacklight::Configuration" do
 
-  before(:each) do
-    @config = config
+  let(:config) do
+    Blacklight::Configuration.new
   end
 
-  let(:config) { Blacklight::Configuration.new }
-
   it "supports arbitrary configuration values" do
-    @config.a = 1
+    config.a = 1
 
-    expect(@config.a).to eq 1
-    expect(@config[:a]).to eq 1
+    expect(config.a).to eq 1
+    expect(config[:a]).to eq 1
   end
 
   describe "initialization" do
     it "is an OpenStructWithHashAccess" do
-      expect(@config).to be_a_kind_of Blacklight::OpenStructWithHashAccess
+      expect(config).to be_a_kind_of Blacklight::OpenStructWithHashAccess
     end
 
     it "accepts a block for configuration" do
@@ -33,46 +31,45 @@ describe "Blacklight::Configuration" do
 
   describe "defaults" do
     it "has a hash of default rsolr query parameters" do
-      expect(@config.default_solr_params).to be_a_kind_of Hash
+      expect(config.default_solr_params).to be_a_kind_of Hash
     end
 
     it "has openstruct values for show and index parameters" do
-      expect(@config.show).to be_a_kind_of OpenStruct
-      expect(@config.index).to be_a_kind_of OpenStruct
+      expect(config.show).to be_a_kind_of OpenStruct
+      expect(config.index).to be_a_kind_of OpenStruct
     end
 
     it "has ordered hashes for field configuration" do
-      expect(@config.facet_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.index_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.show_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.search_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.show_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.search_fields).to be_a_kind_of ActiveSupport::OrderedHash
-      expect(@config.sort_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.facet_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.index_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.show_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.search_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.show_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.search_fields).to be_a_kind_of ActiveSupport::OrderedHash
+      expect(config.sort_fields).to be_a_kind_of ActiveSupport::OrderedHash
     end
-
   end
 
   describe "#connection_config" do
     let(:custom_config) { double }
     it "has the global blacklight configuration" do
-      expect(@config.connection_config).to eq Blacklight.connection_config
+      expect(config.connection_config).to eq Blacklight.connection_config
     end
     it "is overridable with custom configuration" do
-      @config.connection_config = custom_config
-      expect(@config.connection_config).to eq custom_config
+      config.connection_config = custom_config
+      expect(config.connection_config).to eq custom_config
     end
   end
 
   describe "config.index.respond_to" do
     it "has a list of additional formats for index requests to respond to" do
-      @config.index.respond_to.xml = true
+      config.index.respond_to.xml = true
 
-      @config.index.respond_to.csv = { :layout => false }
+      config.index.respond_to.csv = { :layout => false }
 
-      @config.index.respond_to.yaml = lambda { render plain: "" }
+      config.index.respond_to.yaml = lambda { render plain: "" }
 
-      expect(@config.index.respond_to.keys).to eq [:xml, :csv, :yaml]
+      expect(config.index.respond_to.keys).to eq [:xml, :csv, :yaml]
     end
   end
 
@@ -86,25 +83,46 @@ describe "Blacklight::Configuration" do
     end
   end
 
+  describe "for_display_type" do
+    let(:mock_field) { Blacklight::Configuration::IndexField.new }
+    let(:image) { SolrDocument.new(format: 'Image') }
+    let(:sound) { SolrDocument.new(format: 'Sound') }
+    it "adds fields just for a certain type" do
+      config.for_display_type "Image" do |c|
+        c.add_index_field :dimensions
+      end
+      config.add_index_field :title
+
+      expect(config.index_fields_for(image)).to have_key 'dimensions'
+      expect(config.index_fields_for(image)).to have_key 'title'
+      expect(config.index_fields_for(sound)).not_to have_key 'dimensions'
+      expect(config.index_fields_for(image)).to have_key 'title'
+      expect(config.index_fields).not_to have_key 'dimensions'
+    end
+  end
+
   describe "inheritable_copy" do
+    let(:klass) { Class.new }
+    let(:config_copy) { config.inheritable_copy(klass) }
+
+
     it "provides a deep copy of the configuration" do
-      config_copy = @config.inheritable_copy
       config_copy.a = 1
 
       @mock_facet = Blacklight::Configuration::FacetField.new
       config_copy.add_facet_field "dummy_field", @mock_facet
 
-      expect(@config.a).to be_nil
-      expect(@config.facet_fields).to_not include(@mock_facet)
+      expect(config.a).to be_nil
+      expect(config.facet_fields).to_not include(@mock_facet)
     end
 
     context "when model classes are customised" do
-      it "does not dup response_model or document_model" do
-        @config.response_model = Hash
-        @config.document_model = Array
-
-        config_copy = @config.inheritable_copy
+      before do
+        config.response_model = Hash
+        config.document_model = Array
+      end
 
+      it "does not dup response_model or document_model" do
         expect(config_copy.response_model).to eq Hash
         expect(config_copy.document_model).to eq Array
       end
@@ -112,32 +130,26 @@ describe "Blacklight::Configuration" do
 
     context "when model classes are not set" do
       it "leaves response_model and document_model empty" do
-        config_copy = @config.inheritable_copy
-
         expect(config_copy.fetch(:response_model, nil)).to be_nil
         expect(config_copy.fetch(:document_model, nil)).to be_nil
       end
 
       it "returns default classes" do
-        config_copy = @config.inheritable_copy
-
         expect(config_copy.response_model).to eq Blacklight::Solr::Response
         expect(config_copy.document_model).to eq SolrDocument
       end
     end
 
     it "provides cloned copies of mutable data structures" do
-      @config.a = { value: 1 }
-      @config.b = [1,2,3]
-
-      config_copy = @config.inheritable_copy
+      config.a = { value: 1 }
+      config.b = [1,2,3]
 
       config_copy.a[:value] = 2
       config_copy.b << 5
 
-      expect(@config.a[:value]).to eq 1
+      expect(config.a[:value]).to eq 1
       expect(config_copy.a[:value]).to eq 2
-      expect(@config.b).to match_array [1,2,3]
+      expect(config.b).to match_array [1,2,3]
       expect(config_copy.b).to match_array [1,2,3,5]
     end
   end
@@ -172,201 +184,200 @@ describe "Blacklight::Configuration" do
 
   describe "add_facet_field" do
     it "accepts field name and hash form arg" do
-      @config.add_facet_field('format',  :label => "Format", :limit => true)
+      config.add_facet_field('format',  :label => "Format", :limit => true)
 
-      expect(@config.facet_fields["format"]).to_not be_nil
-      expect(@config.facet_fields["format"]["label"]).to eq "Format"
-      expect(@config.facet_fields["format"]["limit"]).to be true
+      expect(config.facet_fields["format"]).to_not be_nil
+      expect(config.facet_fields["format"]["label"]).to eq "Format"
+      expect(config.facet_fields["format"]["limit"]).to be true
     end
 
     it "accepts FacetField obj arg" do
-      @config.add_facet_field("format", Blacklight::Configuration::FacetField.new( :label => "Format"))
+      config.add_facet_field("format", Blacklight::Configuration::FacetField.new( :label => "Format"))
 
-      expect(@config.facet_fields["format"]).to_not be_nil
-      expect(@config.facet_fields["format"]["label"]).to eq "Format"
+      expect(config.facet_fields["format"]).to_not be_nil
+      expect(config.facet_fields["format"]["label"]).to eq "Format"
     end
 
     it "accepts field name and block form" do
-      @config.add_facet_field("format") do |facet|
+      config.add_facet_field("format") do |facet|
         facet.label = "Format"
         facet.limit = true
       end
 
-      expect(@config.facet_fields["format"]).to_not be_nil
-      expect(@config.facet_fields["format"].limit).to be true
+      expect(config.facet_fields["format"]).to_not be_nil
+      expect(config.facet_fields["format"].limit).to be true
     end
 
     it "accepts block form" do
-      @config.add_facet_field do |facet|
+      config.add_facet_field do |facet|
         facet.field = "format"
         facet.label = "Format"
       end
 
-      expect(@config.facet_fields['format']).to_not be_nil
+      expect(config.facet_fields['format']).to_not be_nil
     end
 
     it "accepts a configuration hash" do
-      @config.add_facet_field :field => 'format', :label => 'Format'
-      expect(@config.facet_fields['format']).to_not be_nil
+      config.add_facet_field :field => 'format', :label => 'Format'
+      expect(config.facet_fields['format']).to_not be_nil
     end
 
     it "accepts array form" do
-      @config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }])
+      config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }])
 
-      expect(@config.facet_fields).to have(2).fields
+      expect(config.facet_fields).to have(2).fields
     end
 
     it "accepts array form with a block" do
       expect do |b|
-        @config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }], &b)
+        config.add_facet_field([{ :field => 'format', :label => 'Format'}, { :field => 'publication_date', :label => 'Publication Date' }], &b)
       end.to yield_control.twice
     end
 
-
     it "creates default label from titleized solr field" do
-      @config.add_facet_field("publication_date")
+      config.add_facet_field("publication_date")
 
-      expect(@config.facet_fields["publication_date"].label).to eq "Publication Date"
+      expect(config.facet_fields["publication_date"].label).to eq "Publication Date"
     end
 
     it "allows you to not show the facet in the facet bar" do
-      @config.add_facet_field("publication_date", :show=>false)
+      config.add_facet_field("publication_date", :show=>false)
 
-      expect(@config.facet_fields["publication_date"]['show']).to be false
+      expect(config.facet_fields["publication_date"]['show']).to be false
     end
 
     it "raises on nil solr field name" do
-      expect { @config.add_facet_field(nil) }.to raise_error ArgumentError
+      expect { config.add_facet_field(nil) }.to raise_error ArgumentError
     end
 
     it "looks up and match field names" do
-      allow(config).to receive_messages(reflected_fields: {
+      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"]
+      expect(config.facet_fields.keys).to eq ["some_field_facet", "another_field_facet"]
     end
 
     it "takes wild-carded field names and dereference them to solr fields" do
-      allow(config).to receive(:reflected_fields).and_return(
+      allow(config).to receive_messages(luke_fields: {
         "some_field_facet" => {},
         "another_field_facet" => {},
-        "a_facet_field" => {}
-        )
+        "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"]
+      expect(config.facet_fields.keys).to eq ["some_field_facet", "another_field_facet"]
     end
 
     describe "if/unless conditions with legacy show parameter" do
       it "is hidden if the if condition is false" do
-        expect(@config.add_facet_field("hidden", if: false).if).to eq false
-        expect(@config.add_facet_field("hidden_with_legacy", if: false, show: true).if).to eq false
+        expect(config.add_facet_field("hidden", if: false).if).to eq false
+        expect(config.add_facet_field("hidden_with_legacy", if: false, show: true).if).to eq false
       end
 
       it "is true if the if condition is true" do
-        expect(@config.add_facet_field("hidden", if: true).if).to eq true
-        expect(@config.add_facet_field("hidden_with_legacy", if: true, show: false).if).to eq true
+        expect(config.add_facet_field("hidden", if: true).if).to eq true
+        expect(config.add_facet_field("hidden_with_legacy", if: true, show: false).if).to eq true
       end
 
       it "is true if the if condition is missing" do
-        expect(@config.add_facet_field("hidden", show: true).if).to eq true
+        expect(config.add_facet_field("hidden", show: true).if).to eq true
       end
     end
   end
 
   describe "add_index_field" do
     it "takes hash form" do
-      @config.add_index_field("title_display", :label => "Title")
+      config.add_index_field("title_tsim", :label => "Title")
 
-      expect(@config.index_fields["title_display"]).to_not be_nil
-      expect(@config.index_fields["title_display"].label).to eq "Title"
+      expect(config.index_fields["title_tsim"]).to_not be_nil
+      expect(config.index_fields["title_tsim"].label).to eq "Title"
     end
     it "takes IndexField param" do
-      @config.add_index_field("title_display", Blacklight::Configuration::IndexField.new(:field => "title_display", :label => "Title"))
+      config.add_index_field("title_tsim", Blacklight::Configuration::IndexField.new(:field => "title_display", :label => "Title"))
 
-      expect(@config.index_fields["title_display"]).to_not be_nil
-      expect(@config.index_fields["title_display"].label).to eq "Title"
+      expect(config.index_fields["title_tsim"]).to_not be_nil
+      expect(config.index_fields["title_tsim"].label).to eq "Title"
     end
     it "takes block form" do
-      @config.add_index_field("title_display") do |field|
+      config.add_index_field("title_tsim") do |field|
         field.label = "Title"
       end
-      expect(@config.index_fields["title_display"]).to_not be_nil
-      expect(@config.index_fields["title_display"].label).to eq "Title"
+      expect(config.index_fields["title_tsim"]).to_not be_nil
+      expect(config.index_fields["title_tsim"].label).to eq "Title"
     end
 
     it "creates default label from titleized field" do
-      @config.add_index_field("title_display")
+      config.add_index_field("title_tsim")
 
-      expect(@config.index_fields["title_display"].label).to eq "Title Display"
+      expect(config.index_fields["title_tsim"].label).to eq "Title Tsim"
     end
 
     it "raises on nil solr field name" do
-      expect { @config.add_index_field(nil) }.to raise_error ArgumentError
+      expect { config.add_index_field(nil) }.to raise_error ArgumentError
     end
 
     it "takes wild-carded field names and dereference them to solr fields" do
-      allow(config).to receive(:reflected_fields).and_return(
+      allow(config).to receive_messages(luke_fields: {
         "some_field_display" => {},
         "another_field_display" => {},
-        "a_facet_field" => {}
-      )
+        "a_facet_field" => {},
+        })
       config.add_index_field "*_display"
 
-      expect(@config.index_fields.keys).to eq ["some_field_display", "another_field_display"]
+      expect(config.index_fields.keys).to eq ["some_field_display", "another_field_display"]
     end
 
     it "queries 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"
+      config.add_index_field match: /title.+sim/
+      expect(config.index_fields.keys).to include "subtitle_tsim", "subtitle_vern_ssim", "title_tsim", "title_vern_ssim"
     end
   end
 
   describe "add_show_field" do
     it "takes hash form" do
-      @config.add_show_field("title_display", :label => "Title")
+      config.add_show_field("title_tsim", :label => "Title")
 
-      expect(@config.show_fields["title_display"]).to_not be_nil
-      expect(@config.show_fields["title_display"].label).to eq "Title"
+      expect(config.show_fields["title_tsim"]).to_not be_nil
+      expect(config.show_fields["title_tsim"].label).to eq "Title"
     end
     it "takes ShowField argument" do
-      @config.add_show_field("title_display", Blacklight::Configuration::ShowField.new(:field => "title_display", :label => "Title"))
+      config.add_show_field("title_tsim", Blacklight::Configuration::ShowField.new(:field => "title_display", :label => "Title"))
 
-      expect(@config.show_fields["title_display"]).to_not be_nil
-      expect(@config.show_fields["title_display"].label).to eq  "Title"
+      expect(config.show_fields["title_tsim"]).to_not be_nil
+      expect(config.show_fields["title_tsim"].label).to eq  "Title"
     end
     it "takes block form" do
-      @config.add_show_field("title_display") do |f|
+      config.add_show_field("title_tsim") do |f|
         f.label = "Title"
       end
 
-      expect(@config.show_fields["title_display"]).to_not be_nil
-      expect(@config.show_fields["title_display"].label).to eq  "Title"
+      expect(config.show_fields["title_tsim"]).to_not be_nil
+      expect(config.show_fields["title_tsim"].label).to eq  "Title"
     end
 
     it "creates default label humanized from field" do
-      @config.add_show_field("my_custom_field")
+      config.add_show_field("my_custom_field")
 
-      expect(@config.show_fields["my_custom_field"].label).to eq  "My Custom Field"
+      expect(config.show_fields["my_custom_field"].label).to eq  "My Custom Field"
     end
 
     it "raises on nil solr field name" do
-      expect { @config.add_show_field(nil) }.to raise_error ArgumentError
+      expect { config.add_show_field(nil) }.to raise_error ArgumentError
     end
 
     it "takes wild-carded field names and dereference them to solr fields" do
-      allow(config).to receive(:reflected_fields).and_return(
+      allow(config).to receive_messages(luke_fields: {
         "some_field_display" => {},
         "another_field_display" => {},
-        "a_facet_field" => {}
-      )
+        "a_facet_field" => {},
+        })
       config.add_show_field "*_display"
 
-      expect(@config.show_fields.keys).to eq ["some_field_display", "another_field_display"]
+      expect(config.show_fields.keys).to eq ["some_field_display", "another_field_display"]
     end
 
   end
@@ -424,28 +435,28 @@ describe "Blacklight::Configuration" do
     end
 
     it "raises on nil key" do
-      expect {@config.add_search_field(nil, :foo => "bar")}.to raise_error ArgumentError
+      expect {config.add_search_field(nil, :foo => "bar")}.to raise_error ArgumentError
     end
 
     it "creates default label from titleized field key" do
-      @config.add_search_field("author_name")
+      config.add_search_field("author_name")
 
-      expect(@config.search_fields["author_name"].label).to eq "Author Name"
+      expect(config.search_fields["author_name"].label).to eq "Author Name"
     end
 
     describe "if/unless conditions with legacy include_in_simple_search" do
       it "is hidden if the if condition is false" do
-        expect(@config.add_search_field("hidden", if: false).if).to eq false
-        expect(@config.add_search_field("hidden_with_legacy", if: false, include_in_simple_search: true).if).to eq false
+        expect(config.add_search_field("hidden", if: false).if).to eq false
+        expect(config.add_search_field("hidden_with_legacy", if: false, include_in_simple_search: true).if).to eq false
       end
 
       it "is true if the if condition is true" do
-        expect(@config.add_search_field("hidden", if: true).if).to eq true
-        expect(@config.add_search_field("hidden_with_legacy", if: true, include_in_simple_search: false).if).to eq true
+        expect(config.add_search_field("hidden", if: true).if).to eq true
+        expect(config.add_search_field("hidden_with_legacy", if: true, include_in_simple_search: false).if).to eq true
       end
 
       it "is true if the if condition is missing" do
-        expect(@config.add_search_field("hidden", include_in_simple_search: true).if).to eq true
+        expect(config.add_search_field("hidden", include_in_simple_search: true).if).to eq true
       end
     end
   end
@@ -458,41 +469,41 @@ describe "Blacklight::Configuration" do
     end
 
     it "takes a two-arg form with a hash" do
-      @config.add_sort_field("score desc, pub_date_sort desc, title_sort asc", :label => "relevance")
-
-
-      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
+      config.add_sort_field("score desc, pub_date_si desc, title_si asc", :label => "relevance")
+      expect(config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
     end
 
     it "takes a SortField object" do
-      @config.add_sort_field(Blacklight::Configuration::SortField.new(:label => "relevance", :sort => "score desc, pub_date_sort desc, title_sort asc"
-))
-      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
+      config.add_sort_field(
+        Blacklight::Configuration::SortField.new(label: "relevance",
+                                                 sort: "score desc, pub_date_sort desc, title_sort asc")
+      )
+      expect(config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
     end
 
     it "takes block form" do
-      @config.add_sort_field do |field|
+      config.add_sort_field do |field|
         field.label = "relevance"
-        field.sort = "score desc, pub_date_sort desc, title_sort asc"
+        field.sort = "score desc, pub_date_si desc, title_si asc"
       end
 
-      expect(@config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
+      expect(config.sort_fields.values.find{|f| f.label == "relevance"}).to_not be_nil
 
     end
   end
 
   describe "#default_search_field" do
     it "uses the field with a :default key" do
-      @config.add_search_field('search_field_1')
-      @config.add_search_field('search_field_2', :default => true)
+      config.add_search_field('search_field_1')
+      config.add_search_field('search_field_2', :default => true)
 
-      expect(@config.default_search_field.key).to eq 'search_field_2'
+      expect(config.default_search_field.key).to eq 'search_field_2'
     end
   end
 
   describe "#facet_paginator_class" do
     it "defaults to Blacklight::Solr::FacetPaginator" do
-      expect(@config.facet_paginator_class).to eq Blacklight::Solr::FacetPaginator
+      expect(config.facet_paginator_class).to eq Blacklight::Solr::FacetPaginator
     end
   end
 end