rsolr 0.12.0 → 2.6.0

data/spec/api/error_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Error do
+  def generate_error_with_backtrace(request, response)
+    raise RSolr::Error::Http.new request, response
+  rescue RSolr::Error::Http => exception
+    exception
+  end
+  let (:response_lines) { (1..15).to_a.map { |i| "line #{i}" } }
+  let(:request) { { uri: URI.parse('http://hostname.local:8983/solr/admin/update?wt=json&q=test') } }
+  let(:response_body) { response_lines.join("\n") }
+  let(:response) {{
+    :body   => response_body,
+    :status => 400
+  }}
+  subject { generate_error_with_backtrace(request, response).to_s }
+
+  context "when the response body is wrapped in a <pre> element" do
+    let(:response_body) { "<pre>" + response_lines.join("\n") + "</pre>" }
+
+    it "only shows the first eleven lines of the response" do
+      expect(subject).to match(/line 1\n.+line 11\n\n/m)
+    end
+
+    context "when the response is one line long" do
+      let(:response_body) { "<pre>failed</pre>" }
+      it { should match(/Error: failed/) }
+    end
+  end
+
+  context "when the response body is not wrapped in a <pre> element" do
+
+    it "only shows the first eleven lines of the response" do
+      expect(subject).to match(/line 1\n.+line 11\n\n/m)
+    end
+
+    context "when the response is one line long" do
+      let(:response_body) { 'failed' }
+      it { should match(/Error: failed/) }
+    end
+    context "when the response body contains a msg key" do
+      let(:msg) { "'org.apache.solr.search.SyntaxError: Cannot parse \\':false\\': Encountered \" \":\" \": \"\" at line 1, column 0.'" }
+      let(:response_body) { (response_lines << "'error'=>{'msg'=> #{msg}").join("\n") }
+      it { should include msg }
+    end
+
+    context "when the response body is made of multi-byte chars and encoded by ASCII-8bit" do
+      let (:response_lines) { (1..15).to_a.map { |i| "レスポンス #{i}".b } }
+
+      it "encodes errorlogs by UTF-8" do
+        expect(subject.encoding.to_s).to eq 'UTF-8'
+      end
+    end
+  end
+
+  context "when response is JSON" do
+    let(:response) {{
+      :body   => response_body,
+      :status => 500,
+      :headers => {
+        "content-type" => "application/json;charset=utf-8"
+      }
+
+    }}
+
+    context "and contains a msg key" do
+      let(:msg) { "field 'description_text4_tesim' was indexed without offsets, cannot highlight" }
+      let(:response_body) {<<~EOS
+        {
+          "responseHeader":{
+            "status":500,
+            "QTime":11,
+            "params":{
+              "q":"supercali",
+              "hl":"true",
+              "hl:fl":"description_text4_tesim",
+              "hl.method":"unified",
+              "hl.offsetSource":"postings"
+            }
+          },
+          "response":{"numFound":0,"start":0,"maxScore":127.32743,"numFoundExact":true,"docs":[]},
+          "facet_counts":{
+            "facet_queries":{},
+            "facet_fields":{}
+          },
+          "error":{
+            "msg":"#{msg}",
+            "trace":"java.lang.IllegalArgumentException: field 'description_text4_tesim' was indexed without offsets, cannot highlight\\n\\tat org.apache.lucene.search.uhighlight.FieldHighlighter.highlightOffsetsEnums(FieldHighlighter.java:149)\\n\\tat org.apache.lucene.search.uhighlight.FieldHighlighter.highlightFieldForDoc(FieldHighlighter.java:79)\\n\\tat org.apache.lucene.search.uhighlight.UnifiedHighlighter.highlightFieldsAsObjects(UnifiedHighlighter.java:641)\\n\\tat org.apache.lucene.search.uhighlight.UnifiedHighlighter.highlightFields(UnifiedHighlighter.java:510)\\n\\tat org.apache.solr.highlight.UnifiedSolrHighlighter.doHighlighting(UnifiedSolrHighlighter.java:149)\\n\\tat org.apache.solr.handler.component.HighlightComponent.process(HighlightComponent.java:172)\\n\\tat org.apache.solr.handler.component.SearchHandler.handleRequestBody(SearchHandler.java:331)\\n\\tat org.apache.solr.handler.RequestHandlerBase.handleRequest(RequestHandlerBase.java:214)\\n\\tat org.apache.solr.core.SolrCore.execute(SolrCore.java:2606)\\n\\tat org.apache.solr.servlet.HttpSolrCall.execute(HttpSolrCall.java:815)\\n\\tat org.apache.solr.servlet.HttpSolrCall.call(HttpSolrCall.java:588)\\n\\tat org.apache.solr.servlet.SolrDispatchFilter.doFilter(SolrDispatchFilter.java:415)\\n\\tat org.apache.solr.servlet.SolrDispatchFilter.doFilter(SolrDispatchFilter.java:345)\\n\\tat org.eclipse.jetty.servlet.ServletHandler$CachedChain.doFilter(ServletHandler.java:1596)\\n\\tat org.eclipse.jetty.servlet.ServletHandler.doHandle(ServletHandler.java:545)\\n\\tat org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:143)\\n\\tat org.eclipse.jetty.security.SecurityHandler.handle(SecurityHandler.java:590)\\n\\tat org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:127)\\n\\tat org.eclipse.jetty.server.handler.ScopedHandler.nextHandle(ScopedHandler.java:235)\\n\\tat org.eclipse.jetty.server.session.SessionHandler.doHandle(SessionHandler.java:1610)\\n\\tat org.eclipse.jetty.server.handler.ScopedHandler.nextHandle(ScopedHandler.java:233)\\n\\tat org.eclipse.jetty.server.handler.ContextHandler.doHandle(ContextHandler.java:1300)\\n\\tat org.eclipse.jetty.server.handler.ScopedHandler.nextScope(ScopedHandler.java:188)\\n\\tat org.eclipse.jetty.servlet.ServletHandler.doScope(ServletHandler.java:485)\\n\\tat org.eclipse.jetty.server.session.SessionHandler.doScope(SessionHandler.java:1580)\\n\\tat org.eclipse.jetty.server.handler.ScopedHandler.nextScope(ScopedHandler.java:186)\\n\\tat org.eclipse.jetty.server.handler.ContextHandler.doScope(ContextHandler.java:1215)\\n\\tat org.eclipse.jetty.server.handler.ScopedHandler.handle(ScopedHandler.java:141)\\n\\tat org.eclipse.jetty.server.handler.ContextHandlerCollection.handle(ContextHandlerCollection.java:221)\\n\\tat org.eclipse.jetty.server.handler.InetAccessHandler.handle(InetAccessHandler.java:177)\\n\\tat org.eclipse.jetty.server.handler.HandlerCollection.handle(HandlerCollection.java:146)\\n\\tat org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:127)\\n\\tat org.eclipse.jetty.rewrite.handler.RewriteHandler.handle(RewriteHandler.java:322)\\n\\tat org.eclipse.jetty.server.handler.HandlerWrapper.handle(HandlerWrapper.java:127)\\n\\tat org.eclipse.jetty.server.Server.handle(Server.java:500)\\n\\tat org.eclipse.jetty.server.HttpChannel.lambda$handle$1(HttpChannel.java:383)\\n\\tat org.eclipse.jetty.server.HttpChannel.dispatch(HttpChannel.java:547)\\n\\tat org.eclipse.jetty.server.HttpChannel.handle(HttpChannel.java:375)\\n\\tat org.eclipse.jetty.server.HttpConnection.onFillable(HttpConnection.java:273)\\n\\tat org.eclipse.jetty.io.AbstractConnection$ReadCallback.succeeded(AbstractConnection.java:311)\\n\\tat org.eclipse.jetty.io.FillInterest.fillable(FillInterest.java:103)\\n\\tat org.eclipse.jetty.io.ChannelEndPoint$2.run(ChannelEndPoint.java:117)\\n\\tat org.eclipse.jetty.util.thread.strategy.EatWhatYouKill.runTask(EatWhatYouKill.java:336)\\n\\tat org.eclipse.jetty.util.thread.strategy.EatWhatYouKill.doProduce(EatWhatYouKill.java:313)\\n\\tat org.eclipse.jetty.util.thread.strategy.EatWhatYouKill.tryProduce(EatWhatYouKill.java:171)\\n\\tat org.eclipse.jetty.util.thread.strategy.EatWhatYouKill.run(EatWhatYouKill.java:129)\\n\\tat org.eclipse.jetty.util.thread.ReservedThreadExecutor$ReservedThread.run(ReservedThreadExecutor.java:375)\\n\\tat org.eclipse.jetty.util.thread.QueuedThreadPool.runJob(QueuedThreadPool.java:806)\\n\\tat org.eclipse.jetty.util.thread.QueuedThreadPool$Runner.run(QueuedThreadPool.java:938)\\n\\tat java.base/java.lang.Thread.run(Thread.java:834)\\n",
+            "code":500
+          }
+        }
+      EOS
+      }
+      it {
+        should include msg
+      }
+    end
+
+    context "and does not contain a msg key" do
+      let(:response_body) {<<~EOS
+        {
+          "responseHeader":{
+            "status":500,
+            "QTime":11,
+            "params":{
+              "q":"supercali",
+              "hl":"true",
+              "hl:fl":"description_text4_tesim",
+              "hl.method":"unified",
+              "hl.offsetSource":"postings"
+            }
+          },
+          "response":{"numFound":0,"start":0,"maxScore":127.32743,"numFoundExact":true,"docs":[]},
+          "facet_counts":{
+            "facet_queries":{},
+            "facet_fields":{}
+          },
+        }
+      EOS
+      }
+      it "shows the first eleven lines of the response" do
+        expect(subject).to include(response_body.split("\n")[0..10].join("\n"))
+        expect(subject).not_to include(response_body.split("\n")[11])
+      end
+    end
+
+    context "and is not parseable json" do
+      let(:response_body) {<<~EOS
+        one
+        two
+        three
+        four
+        five
+        six
+        seven
+        eight
+        nine
+        ten
+        eleven
+        twelve
+      EOS
+      }
+    end
+    it "shows the first eleven lines of the response" do
+      expect(subject).to include(response_body.split("\n")[0..10].join("\n"))
+      expect(subject).not_to include(response_body.split("\n")[11])
+    end
+  end
+
+  context "when request uri contains credentials" do
+    let(:request) { { uri: URI.parse('http://admin:admin@hostname.local:8983/solr/admin/update?wt=json&q=test') } }
+
+
+    it 'includes redacted url' do
+      expect(subject).to include 'http://REDACTED:REDACTED@hostname.local:8983/solr/admin/update?wt=json&q=test'
+    end
+  end
+end

data/spec/api/json_spec.rb

@@ -0,0 +1,248 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::JSON do
+
+  let(:generator){ RSolr::JSON::Generator.new }
+
+  context :add do
+    # add a single hash ("doc")
+    it 'should create an add from a hash' do
+      data = {
+        :id=>"1",
+        :name=>'matt'
+      }
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    # add an array of hashes
+    it 'should create many adds from an array of hashes' do
+      data = [
+        {
+          :id=>"1",
+          :name=>'matt'
+        },
+        {
+          :id=>"2",
+          :name=>'sam'
+        }
+      ]
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message).to eq data
+    end
+
+    it 'should yield a Document object when #add is called with a block' do
+      documents = [{:id=>1, :name=>'sam', :cat=>['cat 1', 'cat 2']}]
+      result = generator.add(documents) do |doc|
+        doc.field_by_name(:name).attrs[:boost] = 10
+      end
+
+      message = JSON.parse(result, symbolize_names: true)
+
+      expect(message.length).to eq 1
+      expect(message.first).to include name: { boost: 10, value: 'sam' }
+    end
+
+    context 'with add_attr' do
+      it 'should create an add command with the attributes from a hash' do
+        data = {
+          :id=>"1",
+          :name=>'matt'
+        }
+        message = JSON.parse(generator.add(data, boost: 1), symbolize_names: true)
+        expect(message).to include :add
+        expect(message[:add][:doc]).to eq data
+        expect(message[:add][:boost]).to eq 1
+      end
+
+      it 'should create multiple add command with the attributes from a hash' do
+        data = [
+          {
+            :id=>"1",
+            :name=>'matt'
+          },
+          {
+            :id=>"2",
+            :name=>'sam'
+          },
+        ]
+
+        # custom JSON object class to handle Solr's non-standard JSON command format
+        tmp = Class.new do
+          def initialize
+            @source ||= {}
+          end
+
+          def []=(k, v)
+            if k == :add
+              @source[k] ||= []
+              @source[k] << v.to_h
+            elsif v.class == self.class
+              @source[k] = v.to_h
+            else
+              @source[k] = v
+            end
+          end
+
+          def to_h
+            @source
+          end
+        end
+
+        request = generator.add(data, boost: 1)
+        message = JSON.parse(request, object_class: tmp, symbolize_names: true).to_h
+        expect(message[:add].length).to eq 2
+        expect(message[:add].map { |x| x[:doc] }).to eq data
+      end
+    end
+
+    it 'allows for atomic updates' do
+      data = {
+        foo: { set: 'Bar' }
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    it 'supports nested child documents' do
+      data = {
+        _childDocuments_: [
+          {
+            id: 1
+          },
+          {
+            id: 2
+          }
+        ]
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+
+    it 'supports nested child documents with only a single document' do
+      data = {
+        _childDocuments_: [
+          {
+            id: 1
+          }
+        ]
+      }
+
+      message = JSON.parse(generator.add(data), symbolize_names: true)
+      expect(message.length).to eq 1
+      expect(message.first).to eq data
+    end
+  end
+
+  it 'should create multiple fields from array values' do
+    data = {
+      :id   => "1",
+      :name => ['matt1', 'matt2']
+    }
+    message = JSON.parse(generator.add(data), symbolize_names: true)
+    expect(message.length).to eq 1
+    expect(message.first).to eq data
+  end
+
+  it 'should create multiple fields from array values with options' do
+    test_values = [nil, 'matt1', 'matt2']
+    message = JSON.parse(
+      generator.add(id: '1') { |doc| doc.add_field(:name, test_values, boost: 3) },
+      symbolize_names: true
+    )
+    expect(message).to eq [{ id: '1', name: { boost: 3, value: test_values } }]
+  end
+
+  context 'for atomic updates with arrays' do
+    let(:test_values) { %w[value1 value2] }
+
+    it 'creates single field from array values on SET' do
+      expect(
+        JSON.parse(
+          generator.add(id: 'set-id') { |doc| doc.add_field(:name, test_values, update: :set) },
+          symbolize_names: true
+        )
+      ).to eq [{ id: 'set-id', name: { set: test_values } }]
+    end
+
+    it 'creates single field from array values on ADD' do
+      expect(
+        JSON.parse(
+          generator.add(id: 'add-id') { |doc| doc.add_field(:name, test_values, update: :add) },
+          symbolize_names: true
+        )
+      ).to eq [{ id: 'add-id', name: { add: test_values } }]
+    end
+
+    it 'creates single field from array values on ADD-DISTINCT' do
+      expect(
+        JSON.parse(
+          generator.add(id: 'add-distinct-id') { |doc| doc.add_field(:name, test_values, update: :'add-distinct') },
+          symbolize_names: true
+        )
+      ).to eq [{ id: 'add-distinct-id', name: { 'add-distinct': test_values } }]
+    end
+
+    it 'creates single field from array values on REMOVE' do
+      expect(
+        JSON.parse(
+          generator.add(id: 'remove-id') { |doc| doc.add_field(:name, test_values, update: :remove) },
+          symbolize_names: true
+        )
+      ).to eq [{ id: 'remove-id', name: { remove: test_values } }]
+    end
+
+    it 'creates single field from array values for child document update' do
+      test_nested_values = [{id: 1, name: 'value1'}, {id: 1, name: 'value2'}]
+      expect(
+        JSON.parse(
+          generator.add(id: 'set-id') { |doc| doc.add_field(:child_documents, test_nested_values, update: :set) },
+          symbolize_names: true
+        )
+      ).to eq [{ id: 'set-id', child_documents: { set: test_nested_values } }]
+    end
+  end
+
+  describe '#commit' do
+    it 'generates a commit command' do
+      expect(JSON.parse(generator.commit, symbolize_names: true)).to eq(commit: {})
+    end
+  end
+
+  describe '#optimize' do
+    it 'generates a optimize command' do
+      expect(JSON.parse(generator.optimize, symbolize_names: true)).to eq(optimize: {})
+    end
+  end
+
+  describe '#rollback' do
+    it 'generates a rollback command' do
+      expect(JSON.parse(generator.rollback, symbolize_names: true)).to eq(rollback: {})
+    end
+  end
+
+  describe '#delete_by_id' do
+    it 'generates a delete_by_id command for single documents' do
+      expect(JSON.parse(generator.delete_by_id('x'), symbolize_names: true)).to eq(delete: 'x')
+    end
+
+    it 'generates a delete_by_id command for an array of documents' do
+      expect(JSON.parse(generator.delete_by_id(%w(a b c)), symbolize_names: true)).to eq(delete: %w(a b c))
+    end
+  end
+
+  describe '#delete_by_query' do
+    it 'generates a delete_by_id command for single documents' do
+      expect(JSON.parse(generator.delete_by_query('id:x'), symbolize_names: true)).to eq(delete: { query: 'id:x'})
+    end
+
+    it 'generates a delete_by_id command for an array of documents' do
+      expect(JSON.parse(generator.delete_by_id(%w(a b c)), symbolize_names: true)).to eq(delete: %w(a b c))
+    end
+  end
+end

data/spec/api/pagination_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Client do
+  context "build_paginated_request" do
+    it "should create the proper solr params and query string" do
+      c = RSolr::Client.new(nil, {})#.extend(RSolr::Pagination::Client)
+      r = c.build_paginated_request 3, 25, "select", {:params => {:q => "test"}}
+      #r[:page].should == 3
+      #r[:per_page].should == 25
+      expect(r[:params]["start"]).to eq(50)
+      expect(r[:params]["rows"]).to eq(25)
+      expect(r[:uri].query).to match(/rows=25/)
+      expect(r[:uri].query).to match(/start=50/)
+    end
+  end
+  context "paginate" do
+    it "should build a paginated request context and call execute" do
+      c = RSolr::Client.new(nil, {})#.extend(RSolr::Pagination::Client)
+      expect(c).to receive(:execute).with(hash_including({
+        #:page => 1,
+        #:per_page => 10,
+        :params => {
+          "rows" => 10,
+          "start" => 0,
+          :wt => :json
+        }
+      }))
+      c.paginate 1, 10, "select"
+    end
+  end
+end

data/spec/api/rsolr_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+RSpec.describe RSolr do
+  
+  it "has a version that can be read via #version or VERSION" do
+    expect(RSolr.version).to eq(RSolr::VERSION)
+  end
+
+  context "connect" do
+    it "should return a RSolr::Client instance" do
+      expect(RSolr.connect).to be_a(RSolr::Client)
+    end
+  end
+  
+  context '.solr_escape' do
+    it "adds backslash to Solr query syntax chars" do
+      # per http://lucene.apache.org/core/4_0_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#Escaping_Special_Characters
+      special_chars = [ "+", "-", "&", "|", "!", "(", ")", "{", "}", "[", "]", "^", '"', "~", "*", "?", ":", "\\", "/" ]
+      escaped_str = RSolr.solr_escape("aa#{special_chars.join('aa')}aa")
+      special_chars.each { |c|
+        # note that the ruby code sending the query to Solr will un-escape the backslashes
+        # so the result sent to Solr is ultimately a single backslash in front of the particular character 
+        expect(escaped_str).to match "\\#{c}"
+      }
+    end
+    it "leaves other chars alone" do
+      str = "nothing to see here; let's move along people."
+      expect(RSolr.solr_escape(str)).to eq str
+    end
+  end
+end

data/spec/api/uri_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe RSolr::Uri do
+  
+  let(:uri) { RSolr::Uri }
+
+  context '.params_to_solr' do
+    it "converts Hash to Solr query string w/o a starting ?" do
+      hash = {:q => "gold", :fq => ["mode:one", "level:2"]}
+      query = uri.params_to_solr hash
+      expect(query[0]).not_to eq(??)
+      [/q=gold/, /fq=mode%3Aone/, /fq=level%3A2/].each do |p|
+        expect(query).to match p
+      end
+      expect(query.split('&').size).to eq(3)
+    end
+    it 'should URL escape &' do
+      expect(uri.params_to_solr(:fq => "&")).to eq('fq=%26')
+    end
+
+    it 'should convert spaces to +' do
+      expect(uri.params_to_solr(:fq => "me and you")).to eq('fq=me+and+you')
+    end
+
+    it 'should URL escape complex queries, part 1' do
+      my_params = {'fq' => '{!raw f=field_name}crazy+\"field+value'}
+      expected = 'fq=%7B%21raw+f%3Dfield_name%7Dcrazy%2B%5C%22field%2Bvalue'
+      expect(uri.params_to_solr(my_params)).to eq(expected)
+    end
+
+    it 'should URL escape complex queries, part 2' do
+      my_params = {'q' => '+popularity:[10 TO *] +section:0'}
+      expected = 'q=%2Bpopularity%3A%5B10+TO+*%5D+%2Bsection%3A0'
+      expect(uri.params_to_solr(my_params)).to eq(expected)
+    end
+  end
+end