blacklight 6.21.0 → 7.0.0

data/spec/models/blacklight/icon_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Blacklight::Icon do
+  subject { described_class.new(:search, classes: 'awesome') }
+
+  describe '#svg' do
+    it 'returns a string' do
+      expect(subject.svg).to be_an String
+    end
+    it 'returns raw svg' do
+      expect(Capybara.string(subject.svg))
+        .to have_css 'svg title', text: 'Search'
+    end
+  end
+
+  describe '#options' do
+    it 'applies options classes and default class' do
+      expect(subject.options[:class]).to eq 'blacklight-icons awesome'
+    end
+  end
+
+  describe '#path' do
+    it 'prepends blacklight and sufixes .svg' do
+      expect(subject.path).to eq 'blacklight/search.svg'
+    end
+  end
+
+  describe 'file_source' do
+    context 'file is not available' do
+      subject { described_class.new(:yolo) }
+
+      it {
+        expect { subject.file_source }
+          .to raise_error(Blacklight::Exceptions::IconNotFound)
+      }
+    end
+
+    context 'file is available' do
+      it 'returns the filesource' do
+        expect(subject.file_source).to include '<svg'
+      end
+    end
+  end
+end

data/spec/models/blacklight/search_builder_spec.rb

@@ -1,28 +1,17 @@
 # frozen_string_literal: true
 
-describe Blacklight::SearchBuilder do
+RSpec.describe Blacklight::SearchBuilder, api: true do
+  subject(:builder) { described_class.new processor_chain, scope }
+
   let(:processor_chain) { [] }
   let(:blacklight_config) { Blacklight::Configuration.new }
   let(:scope) { double blacklight_config: blacklight_config }
-  subject { described_class.new processor_chain, scope }
 
   context "with default processor chain" do
-    context "with two arguments" do
-      subject do
-        Deprecation.silence Blacklight::SearchBuilder do
-          described_class.new true, scope
-        end
-      end
-      it "uses the class-level default_processor_chain" do
-        expect(subject.processor_chain).to eq []
-      end
-    end
+    subject { described_class.new scope }
 
-    context "with one arguments" do
-      subject { described_class.new scope }
-      it "uses the class-level default_processor_chain" do
-        expect(subject.processor_chain).to eq []
-      end
+    it "uses the class-level default_processor_chain" do
+      expect(subject.processor_chain).to eq []
     end
   end
 
@@ -44,6 +33,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#processor_chain" do
     let(:processor_chain) { [:a, :b, :c] }
+
     it "is mutable" do
       subject.processor_chain.insert(-1, :d)
       expect(subject.processor_chain).to match_array [:a, :b, :c, :d]
@@ -52,6 +42,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#append" do
     let(:processor_chain) { [:a, :b, :c] }
+
     it "provides a new search builder with the processor chain" do
       builder = subject.append(:d, :e)
       expect(subject.processor_chain).to eq processor_chain
@@ -62,6 +53,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#except" do
     let(:processor_chain) { [:a, :b, :c, :d, :e] }
+
     it "provide a new search builder excepting arguments" do
       builder = subject.except(:b, :d, :does_not_exist)
       expect(builder).not_to equal(subject)
@@ -82,11 +74,13 @@ describe Blacklight::SearchBuilder do
 
   describe "#merge" do
     let(:processor_chain) { [:pass_through] }
+
     before do
       allow(subject).to receive(:pass_through) do |req_params|
         req_params.replace subject.blacklight_params
       end
     end
+
     it "overwrites the processed parameters" do
       actual = subject.with(q: 'abc').merge(q: 'xyz')
       expect(actual[:q]).to eq 'xyz'
@@ -95,6 +89,7 @@ describe Blacklight::SearchBuilder do
 
   describe "#reverse_merge" do
     let(:processor_chain) { [:pass_through] }
+
     before do
       allow(subject).to receive(:pass_through) do |req_params|
         req_params.replace subject.blacklight_params
@@ -176,18 +171,38 @@ describe Blacklight::SearchBuilder do
   end
 
   describe "#sort" do
-    it "passes through the sort parameter" do
-      expect(subject.with(sort: 'x').send(:sort)).to eq 'x'
-    end
+    context "when no sort parameter is given" do
+      subject(:sort) { builder.send(:sort) }
 
-    it "uses the default if no sort parameter is given" do
-      blacklight_config.default_sort_field = double(sort: 'x desc')
-      expect(subject.send(:sort)).to eq 'x desc'
+      before do
+        blacklight_config.default_sort_field = double(sort: 'x desc')
+      end
+
+      it "uses the default" do
+        expect(sort).to eq 'x desc'
+      end
     end
 
-    it "uses the requested sort field" do
-      blacklight_config.add_sort_field 'x', sort: 'x asc'
-      expect(subject.with(sort: 'x').send(:sort)).to eq 'x asc'
+    context "when the user provides an sort parameter" do
+      subject(:sort) { builder_with_param.send(:sort) }
+
+      let(:builder_with_param) { builder.with(sort: 'x') }
+
+      context "that is invalid" do
+        it "removes them" do
+          expect(sort).to be_nil
+        end
+      end
+
+      context "that is valid" do
+        before do
+          blacklight_config.add_sort_field 'x', sort: 'x asc'
+        end
+
+        it "uses the requested sort field" do
+          expect(sort).to eq 'x asc'
+        end
+      end
     end
   end
 

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

@@ -1,280 +1,288 @@
 # frozen_string_literal: true
 
-describe "Blacklight::Solr::Document" do
-    class MockDocument
-      include Blacklight::Solr::Document
-    end
+RSpec.describe "Blacklight::Solr::Document", api: true do
+  class MockDocument
+    include Blacklight::Solr::Document
+  end
 
-    module MockExtension
-      def my_extension_method
-        "my_extension_results"
-      end
+  module MockExtension
+    def my_extension_method
+      "my_extension_results"
     end
+  end
 
-    module MockSecondExtension
-      def my_extension_method
-        "override"
-      end
+  module MockSecondExtension
+    def my_extension_method
+      "override"
     end
+  end
 
-    context "Hashy methods" do
-      it 'should create a doc with hashy methods' do
-        doc = SolrDocument.new({'id'=>'SP2514N','inStock'=>true,'manu'=>'Samsung Electronics Co. Ltd.','name'=>'Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133','popularity'=>6,'price'=>92.0,'sku'=>'SP2514N','timestamp'=>'2009-03-20T14:42:49.795Z','cat'=>['electronics','hard drive'],'spell'=>['Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133'],'features'=>['7200RPM, 8MB cache, IDE Ultra ATA-133','NoiseGuard, SilentSeek technology, Fluid Dynamic Bearing (FDB) motor']})
+  context "Hashy methods" do
+    it 'creates a doc with hashy methods' do
+      doc = SolrDocument.new('id' => 'SP2514N', 'inStock' => true, 'manu' => 'Samsung Electronics Co. Ltd.', 'name' => 'Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133', 'popularity' => 6, 'price' => 92.0, 'sku' => 'SP2514N', 'timestamp' => '2009-03-20T14:42:49.795Z', 'cat' => ['electronics', 'hard drive'], 'spell' => ['Samsung SpinPoint P120 SP2514N - hard drive - 250 GB - ATA-133'], 'features' => ['7200RPM, 8MB cache, IDE Ultra ATA-133', 'NoiseGuard, SilentSeek technology, Fluid Dynamic Bearing (FDB) motor'])
 
-        expect(doc.has?(:cat, /^elec/)).to eq true
-        expect(doc.has?(:cat, 'elec')).not_to eq true
-        expect(doc.has?(:cat, 'electronics')).to eq true
+      expect(doc.has?(:cat, /^elec/)).to eq true
+      expect(doc.has?(:cat, 'elec')).not_to eq true
+      expect(doc.has?(:cat, 'electronics')).to eq true
 
-        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
+      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
 
-   
-    context "Unique Key" do
-      before(:each) do
-        MockDocument.unique_key = 'my_unique_key'
-      end
+  context "Unique Key" do
+    before do
+      MockDocument.unique_key = 'my_unique_key'
+    end
 
-      after(:each) do
-        MockDocument.unique_key = 'id'
-      end
-      it "should use a configuration-defined document unique key" do
-        @document = MockDocument.new :id => 'asdf', :my_unique_key => '1234'
-        expect(@document.id).to eq '1234'
-      end
+    after do
+      MockDocument.unique_key = 'id'
+    end
 
+    it "uses a configuration-defined document unique key" do
+      @document = MockDocument.new id: 'asdf', my_unique_key: '1234'
+      expect(@document.id).to eq '1234'
     end
+  end
 
-    describe "Primary key" do
-      before(:each) do
-        MockDocument.unique_key = 'my_unique_key'
-      end
-      after(:each) do
-        MockDocument.unique_key = 'id'
-      end
-      it "should be the same as the unique key" do
-        expect(MockDocument.primary_key).to eq MockDocument.unique_key
-      end
+  describe "Primary key" do
+    before do
+      MockDocument.unique_key = 'my_unique_key'
     end
 
-    describe "#to_param" do
-      it "should be a string" do
-        @document = MockDocument.new :id => 1234
-        expect(@document.to_param).to eq '1234'
-      end
+    after do
+      MockDocument.unique_key = 'id'
     end
 
-    context "Extendability" do
-      before(:each) do
-        #Clear extensions
-        MockDocument.registered_extensions = []
-      end
-    
-      it "should let you register an extension" do
-        MockDocument.use_extension(MockExtension) { |doc| true }
+    it "is the same as the unique key" do
+      expect(MockDocument.primary_key).to eq MockDocument.unique_key
+    end
+  end
 
-        expect(MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}).not_to be_nil
-      end
-      it "should let you register an extension with a nil condition proc" do
-        MockDocument.use_extension(MockExtension) { |doc| true }
-        expect(MockDocument.registered_extensions.find {|a| a[:module_obj] == MockExtension}).not_to be_nil
-      end
-      it "should apply an extension whose condition is met" do
-        MockDocument.use_extension(MockExtension) {|doc| true}
-        doc = MockDocument.new()
+  describe "#to_param" do
+    it "is a string" do
+      @document = MockDocument.new id: 1234
+      expect(@document.to_param).to eq '1234'
+    end
+  end
 
-        expect(doc.methods.find {|name| name.to_s == "my_extension_method"}).not_to be_nil
-        expect(doc.my_extension_method.to_s).to eq "my_extension_results"
-      end
-      it "should apply an extension based on a Solr field" do
-        MockDocument.use_extension(MockExtension) {|doc| doc.key?(:required_key)}
+  context "Extendability" do
+    before do
+      # Clear extensions
+      MockDocument.registered_extensions = []
+    end
 
-        with_extension = MockDocument.new(:required_key => "value")
-        expect(with_extension.my_extension_method.to_s).to eq "my_extension_results"
+    it "lets you register an extension" do
+      MockDocument.use_extension(MockExtension) { |_doc| true }
 
-        without_extension = MockDocument.new(:other_key => "value")
-        expect(without_extension.methods.find {|name| name.to_s == "my_extension_method"}).to be_nil
-        
-      end
-      it "should not apply an extension whose condition is not met" do
-        MockDocument.use_extension(MockExtension) {|doc| false}
-        doc = MockDocument.new()
-  
-        expect(doc.methods.find {|name| name.to_s == "my_extension_method"}).to be_nil      
-      end
-      it "should treat a nil condition as always applyable" do
-        MockDocument.use_extension(MockExtension)
-  
-        doc = MockDocument.new()
-  
-        expect(doc.methods.find {|name | name.to_s =="my_extension_method"}).not_to be_nil
-        expect(doc.my_extension_method).to eq "my_extension_results"
-      end
-      it "should let last extension applied override earlier extensions" do
-        MockDocument.use_extension(MockExtension)
-        MockDocument.use_extension(MockSecondExtension)
+      expect(MockDocument.registered_extensions.find { |a| a[:module_obj] == MockExtension }).not_to be_nil
+    end
+    it "lets you register an extension with a nil condition proc" do
+      MockDocument.use_extension(MockExtension) { |_doc| true }
+      expect(MockDocument.registered_extensions.find { |a| a[:module_obj] == MockExtension }).not_to be_nil
+    end
+    it "applies an extension whose condition is met" do
+      MockDocument.use_extension(MockExtension) { |_doc| true }
+      doc = MockDocument.new
 
-        expect(MockDocument.new().my_extension_method.to_s).to eq "override"        
-      end
+      expect(doc.methods.find { |name| name.to_s == "my_extension_method" }).not_to be_nil
+      expect(doc.my_extension_method.to_s).to eq "my_extension_results"
+    end
+    it "applies an extension based on a Solr field" do
+      MockDocument.use_extension(MockExtension) { |doc| doc.key?(:required_key) }
 
-      describe "extension_parameters class-level hash" do
-        it "should provide an extension_parameters hash at the class level" do
-          MockDocument.extension_parameters[:key] = "value"
-          expect(MockDocument.extension_parameters[:key]).to eq "value"
-        end
-    
-        it "extension_parameters should not be shared between classes" do
-          class_one = Class.new do
-            include Blacklight::Solr::Document
-          end
-          class_two = Class.new do
-            include Blacklight::Solr::Document
-          end
-
-          class_one.extension_parameters[:key] = "class_one_value"
-          class_two.extension_parameters[:key] = "class_two_value"
-
-          expect(class_one.extension_parameters[:key]).to eq "class_one_value"
-        end
-      end
-      
+      with_extension = MockDocument.new(required_key: "value")
+      expect(with_extension.my_extension_method.to_s).to eq "my_extension_results"
+
+      without_extension = MockDocument.new(other_key: "value")
+      expect(without_extension.methods.find { |name| name.to_s == "my_extension_method" }).to be_nil
     end
+    it "does not apply an extension whose condition is not met" do
+      MockDocument.use_extension(MockExtension) { |_doc| false }
+      doc = MockDocument.new
 
-    context "Will export as" do
-      class MockDocument
-        include Blacklight::Solr::Document
+      expect(doc.methods.find { |name| name.to_s == "my_extension_method" }).to be_nil
+    end
+    it "treats a nil condition as always applyable" do
+      MockDocument.use_extension(MockExtension)
 
-        def export_as_marc
-          "fake_marc"
-        end
-      end
+      doc = MockDocument.new
 
-      it "reports it's exportable formats properly" do
-        doc = MockDocument.new
-        doc.will_export_as(:marc, "application/marc" )
-        expect(doc.export_formats).to have_key(:marc)
-        expect(doc.export_formats[:marc][:content_type]).to eq "application/marc"
-      end
+      expect(doc.methods.find { |name| name.to_s == "my_extension_method" }).not_to be_nil
+      expect(doc.my_extension_method).to eq "my_extension_results"
+    end
+    it "lets last extension applied override earlier extensions" do
+      MockDocument.use_extension(MockExtension)
+      MockDocument.use_extension(MockSecondExtension)
+
+      expect(MockDocument.new.my_extension_method.to_s).to eq "override"
+    end
 
-      it "looks up content-type from Mime::Type if not given in arg" do
-        doc = MockDocument.new
-        doc.will_export_as(:html)
-        expect(doc.export_formats).to have_key(:html)        
+    describe "extension_parameters class-level hash" do
+      it "provides an extension_parameters hash at the class level" do
+        MockDocument.extension_parameters[:key] = "value"
+        expect(MockDocument.extension_parameters[:key]).to eq "value"
       end
 
-      context "format not registered with Mime::Type" do
-        before(:all) do
-          @doc = MockDocument.new
-          @doc.will_export_as(:mock2, "application/mock2" )
-          # Mime::Type doesn't give us a good way to clean up our new
-          # registration in an after, sorry. 
+      it "extension_parameters should not be shared between classes" do
+        class_one = Class.new do
+          include Blacklight::Solr::Document
         end
-        it "registers format" do
-          expect(defined?("Mime::MOCK2")).to be_truthy
+        class_two = Class.new do
+          include Blacklight::Solr::Document
         end
-        it "registers as alias only" do
-          expect(Mime::Type.lookup("application/mock2")).not_to equal Mime::Type.lookup_by_extension("mock2")
-        end
-      end
 
-      it "export_as(:format) by calling export_as_format" do
-        doc = MockDocument.new
-        doc.will_export_as(:marc, "application/marc")
-        expect(doc.export_as(:marc)).to eq "fake_marc"
-      end
-      
-      it "should know if a document is exportable" do
-        doc = MockDocument.new
-        doc.will_export_as(:marc, "application/marc")
-        expect(doc.exports_as?(:marc)).to be true
+        class_one.extension_parameters[:key] = "class_one_value"
+        class_two.extension_parameters[:key] = "class_two_value"
+
+        expect(class_one.extension_parameters[:key]).to eq "class_one_value"
       end
     end
+  end
 
-    context "to_semantic_fields" do
-      class MockDocument
-          include Blacklight::Solr::Document                        
-      end
-      before do
-        MockDocument.field_semantics.merge!(
-          title: ["title_field", "other_title"],
-          author: "author_field",
-          something: "something_field"
-        )
-
-        @doc1 = MockDocument.new( 
-           "title_field" => "doc1 title",
-           "other_title" => "doc1 title other",
-           "something_field" => ["val1", "val2"],
-           "not_in_list_field" => "weird stuff" 
-         )
+  context "Will export as" do
+    class MockDocument
+      include Blacklight::Solr::Document
+
+      def export_as_marc
+        "fake_marc"
       end
+    end
+
+    it "reports it's exportable formats properly" do
+      doc = MockDocument.new
+      doc.will_export_as(:marc, "application/marc")
+      expect(doc.export_formats).to have_key(:marc)
+      expect(doc.export_formats[:marc][:content_type]).to eq "application/marc"
+    end
 
-      it "should return complete dictionary based on config'd fields" do        
-        expect(@doc1.to_semantic_values)
-          .to eq title: ["doc1 title", "doc1 title other"], something: ["val1", "val2"]
-      end      
-      it "should return empty array for a key without a value" do
-        expect(@doc1.to_semantic_values[:author]).to be_empty
-        expect(@doc1.to_semantic_values[:nonexistent_token]).to be_empty
+    it "looks up content-type from Mime::Type if not given in arg" do
+      doc = MockDocument.new
+      doc.will_export_as(:html)
+      expect(doc.export_formats).to have_key(:html)
+    end
+
+    context "format not registered with Mime::Type" do
+      before(:all) do
+        @doc = MockDocument.new
+        @doc.will_export_as(:mock2, "application/mock2")
+        # Mime::Type doesn't give us a good way to clean up our new
+        # registration in an after, sorry.
       end
-      it "should return an array even for a single-value field" do
-        expect(@doc1.to_semantic_values[:title]).to be_kind_of(Array)
+
+      it "registers format" do
+        expect(defined?("Mime::MOCK2")).to be_truthy
       end
-      it "should return complete array for a multi-value field" do
-        expect(@doc1.to_semantic_values[:something]).to eq ["val1", "val2"] 
+      it "registers as alias only" do
+        expect(Mime::Type.lookup("application/mock2")).not_to equal Mime::Type.lookup_by_extension("mock2")
       end
-      
     end
 
-    context "highlighting" do
+    it "export_as(:format) by calling export_as_format" do
+      doc = MockDocument.new
+      doc.will_export_as(:marc, "application/marc")
+      expect(doc.export_as(:marc)).to eq "fake_marc"
+    end
 
-      before(:all) do
-        @document = MockDocument.new({'id' => 'doc1', 'title_field' => 'doc1 title'}, {'highlighting' => { 'doc1' => { 'title_text' => ['doc <em>1</em>']}, 'doc2' => { 'title_text' => ['doc 2']}}})
+    it "knows if a document is exportable" do
+      doc = MockDocument.new
+      doc.will_export_as(:marc, "application/marc")
+      expect(doc.exports_as?(:marc)).to be true
+    end
+  end
 
-      end
+  context "to_semantic_fields" do
+    class MockDocument
+      include Blacklight::Solr::Document
+    end
+    before do
+      MockDocument.field_semantics.merge!(
+        title: %w[title_field other_title],
+        author: "author_field",
+        something: "something_field"
+      )
+
+      @doc1 = MockDocument.new(
+        "title_field" => "doc1 title",
+        "other_title" => "doc1 title other",
+        "something_field" => %w[val1 val2],
+        "not_in_list_field" => "weird stuff"
+      )
+    end
 
-      describe "#has_highlight_field?" do
-        it "should be true if the highlight field is in the solr response" do
-          expect(@document).to have_highlight_field 'title_text'
-          expect(@document).to have_highlight_field :title_text
-        end
+    it "returns complete dictionary based on config'd fields" do
+      expect(@doc1.to_semantic_values)
+        .to eq title: ["doc1 title", "doc1 title other"], something: %w[val1 val2]
+    end
+    it "returns empty array for a key without a value" do
+      expect(@doc1.to_semantic_values[:author]).to be_empty
+      expect(@doc1.to_semantic_values[:nonexistent_token]).to be_empty
+    end
+    it "returns an array even for a single-value field" do
+      expect(@doc1.to_semantic_values[:title]).to be_kind_of(Array)
+    end
+    it "returns complete array for a multi-value field" do
+      expect(@doc1.to_semantic_values[:something]).to eq %w[val1 val2]
+    end
+  end
 
-        it "should be false if the highlight field isn't in the solr response" do
-           expect(@document).to_not have_highlight_field 'nonexisting_field'
-        end
+  context "highlighting" do
+    before(:all) do
+      @document = MockDocument.new({ 'id' => 'doc1', 'title_field' => 'doc1 title' }, 'highlighting' => { 'doc1' => { 'title_tsimext' => ['doc <em>1</em>'] }, 'doc2' => { 'title_tsimext' => ['doc 2'] } })
+    end
+
+    describe "#has_highlight_field?" do
+      it "is true if the highlight field is in the solr response" do
+        expect(@document).to have_highlight_field 'title_tsimext'
+        expect(@document).to have_highlight_field :title_tsimext
       end
 
-      describe "#highlight_field" do
-        it "should return a value" do
-          expect(@document.highlight_field('title_text')).to include('doc <em>1</em>')
-        end
+      it "is false if the highlight field isn't in the solr response" do
+        expect(@document).not_to have_highlight_field 'nonexisting_field'
+      end
+    end
 
+    describe "#highlight_field" do
+      it "returns a value" do
+        expect(@document.highlight_field('title_tsimext')).to include('doc <em>1</em>')
+      end
 
-        it "should return a value that is html safe" do
-          expect(@document.highlight_field('title_text').first).to be_html_safe
-        end
+      it "returns a value that is html safe" do
+        expect(@document.highlight_field('title_tsimext').first).to be_html_safe
+      end
 
-        it "should return nil when the field doesn't exist" do
-          expect(@document.highlight_field('nonexisting_field')).to be_nil
-        end
+      it "returns nil when the field doesn't exist" do
+        expect(@document.highlight_field('nonexisting_field')).to be_nil
       end
     end
+  end
 
   describe "#first" do
-    it "should get the first value from a multi-valued field" do
-      doc = SolrDocument.new :multi => ['a', 'b']
-      expect(doc.first :multi).to eq("a")
+    it "gets the first value from a multi-valued field" do
+      doc = SolrDocument.new multi: %w[a b]
+      expect(doc.first(:multi)).to eq("a")
+    end
+
+    it "gets the value from a single-valued field" do
+      doc = SolrDocument.new single: 'a'
+      expect(doc.first(:single)).to eq("a")
     end
+  end
+
+  describe '#more_like_this' do
+    subject(:result) { document.more_like_this }
 
-    it "should get the value from a single-valued field" do
-      doc = SolrDocument.new :single => 'a'
-      expect(doc.first :single).to eq("a")
+    let(:response) { instance_double(Blacklight::Solr::Response, more_like: [{ 'id' => 'abc' }]) }
+    let(:document) { MockDocument.new({ id: '123' }, response) }
 
+    it "plucks the MoreLikeThis results from the Solr Response" do
+      expect(result).to have(1).item
+      expect(result.first).to be_a_kind_of(MockDocument)
+      expect(result.first.id).to eq 'abc'
+      expect(result.first.solr_response).to eq response
     end
   end
-    
 end