rsolr 1.0.8 → 1.1.2

data/spec/api/connection_spec.rb

@@ -2,73 +2,137 @@ require 'spec_helper'
 require 'base64'
 
 describe "RSolr::Connection" do
-  
+
   context "setup_raw_request" do
-    c = RSolr::Connection.new
-    base_url = "http://localhost:8983/solr"
-    client = RSolr::Client.new c, :url => base_url
-    req = c.send :setup_raw_request, {:headers => {"content-type" => "text/xml"}, :method => :get, :uri => URI.parse(base_url + "/select?q=*:*")}
-    req.path.should == "/solr/select?q=*:*"
-    headers = {}
-    req.each_header{|k,v| headers[k] = v}
-    headers.should == {"content-type"=>"text/xml"}
+    it "should set the correct request parameters" do
+      c = RSolr::Connection.new
+      base_url = "http://localhost:8983/solr"
+      client = RSolr::Client.new c, :url => base_url
+      req = c.send :setup_raw_request, {:headers => {"content-type" => "text/xml"}, :method => :get, :uri => URI.parse(base_url + "/select?q=*:*")}
+      expect(req.path).to eq("/solr/select?q=*:*")
+      headers = {}
+      req.each_header{|k,v| headers[k] = v}
+      expect(headers).to eq({"content-type"=>"text/xml"})
+    end
+  end
+
+  context "when the connection is refused" do
+    subject { RSolr::Connection.new }
+
+    it "raises a custom exception" do
+      http_stub = double("Net:HTTP")
+      allow(http_stub).to receive(:request).and_raise(Errno::ECONNREFUSED)
+
+      allow(subject).to receive(:setup_raw_request) { http_stub }
+      allow(subject).to receive(:http) { Net::HTTP.new("localhost", 80) }
+
+      expect { subject.execute(nil, {}) }.to raise_error(RSolr::Error::ConnectionRefused)
+    end
   end
 
   context "read timeout configuration" do
-    let(:client) { mock.as_null_object }
+    let(:client) { double.as_null_object }
 
-    let(:http) { mock(Net::HTTP).as_null_object }
+    let(:http) { double(Net::HTTP).as_null_object }
 
-    subject { RSolr::Connection.new } 
+    subject { RSolr::Connection.new }
 
     before do
-      Net::HTTP.stub(:new) { http }
+      allow(Net::HTTP).to receive(:new) { http }
     end
 
     it "should configure Net:HTTP read_timeout" do
-      http.should_receive(:read_timeout=).with(42)
+      expect(http).to receive(:read_timeout=).with(42)
       subject.execute client, {:uri => URI.parse("http://localhost/some_uri"), :method => :get, :read_timeout => 42}
     end
 
     it "should use Net:HTTP default read_timeout if not specified" do
-      http.should_not_receive(:read_timeout=)
+      expect(http).not_to receive(:read_timeout=)
       subject.execute client, {:uri => URI.parse("http://localhost/some_uri"), :method => :get}
     end
   end
 
   context "open timeout configuration" do
-    let(:client) { mock.as_null_object }
+    let(:client) { double.as_null_object }
 
-    let(:http) { mock(Net::HTTP).as_null_object }
+    let(:http) { double(Net::HTTP).as_null_object }
 
-    subject { RSolr::Connection.new } 
+    subject { RSolr::Connection.new }
 
     before do
-      Net::HTTP.stub(:new) { http }
+      allow(Net::HTTP).to receive(:new) { http }
     end
 
     it "should configure Net:HTTP open_timeout" do
-      http.should_receive(:open_timeout=).with(42)
+      expect(http).to receive(:open_timeout=).with(42)
       subject.execute client, {:uri => URI.parse("http://localhost/some_uri"), :method => :get, :open_timeout => 42}
     end
 
     it "should use Net:HTTP default open_timeout if not specified" do
-      http.should_not_receive(:open_timeout=)
+      expect(http).not_to receive(:open_timeout=)
       subject.execute client, {:uri => URI.parse("http://localhost/some_uri"), :method => :get}
     end
   end
-  
+
+  context "proxy configuration" do
+    let(:client) { double.as_null_object }
+
+    let(:http) { double(Net::HTTP).as_null_object }
+
+    let(:uri) { URI.parse("http://localhost/some_url") }
+    let(:proxy) { URI.parse("http://my.proxy/") }
+
+    subject { RSolr::Connection.new }
+
+    it "should use the default if no proxy is provided" do
+      expect(Net::HTTP).to receive(:new).with(uri.host, uri.port) { http }
+      subject.execute client, { :uri => uri, :method => :get }
+    end
+
+    it "should use the proxy if one is provided" do
+      expect(Net::HTTP).to receive(:Proxy).with(proxy.host, proxy.port, nil, nil) { http }
+      subject.execute client, { :uri => uri, :proxy => proxy, :method => :get }
+    end
+
+    it "should not use a proxy if proxy setting is false" do
+      expect(Net::HTTP).to receive(:new).with(uri.host, uri.port, nil) { http }
+      subject.execute client, { :uri => uri, :proxy => false, :method => :get }
+    end
+  end
+
+  context "connection refused" do
+    let(:client) { double.as_null_object }
+
+    let(:http) { double(Net::HTTP).as_null_object }
+    let(:request_context) {
+      {:uri => URI.parse("http://localhost/some_uri"), :method => :get, :open_timeout => 42}
+    }
+    subject { RSolr::Connection.new }
+
+    before do
+      allow(Net::HTTP).to receive(:new) { http }
+    end
+
+    it "should configure Net:HTTP open_timeout" do
+      skip "doesn't work with ruby 1.8" if RUBY_VERSION < "1.9"
+      expect(http).to receive(:request).and_raise(Errno::ECONNREFUSED)
+      expect {
+        subject.execute client, request_context
+      }.to raise_error(Errno::ECONNREFUSED, /#{request_context}/)
+    end
+  end
+
   describe "basic auth support" do
-    let(:http) { mock(Net::HTTP).as_null_object }
-    
+    let(:http) { double(Net::HTTP).as_null_object }
+
     before do
-      Net::HTTP.stub(:new) { http }
+      allow(Net::HTTP).to receive(:new) { http }
     end
-    
+
     it "sets the authorization header" do
-      http.should_receive(:request) do |request|
-        request.fetch('authorization').should == "Basic #{Base64.encode64("joe:pass")}".strip
-        mock(Net::HTTPResponse).as_null_object
+      expect(http).to receive(:request) do |request|
+        expect(request.fetch('authorization')).to eq("Basic #{Base64.encode64("joe:pass")}".strip)
+        double(Net::HTTPResponse).as_null_object
       end
       RSolr::Connection.new.execute nil, :uri => URI.parse("http://joe:pass@localhost:8983/solr"), :method => :get
     end

data/spec/api/error_spec.rb

@@ -5,52 +5,42 @@ describe "RSolr::Error" do
   rescue RSolr::Error::Http => exception
     exception
   end
+  let (:response_lines) { (1..15).to_a.map { |i| "line #{i}" } }
+  let(:request)  { double :[] => "mocked" }
+  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
-    before do
-      response_lines = (1..15).to_a.map { |i| "line #{i}" }
-
-      @request  = mock :[] => "mocked"
-      @response = {
-        :body   => "<pre>" + response_lines.join("\n") + "</pre>",
-        :status => 400
-      }
-    end
+    let(:response_body) { "<pre>" + response_lines.join("\n") + "</pre>" }
 
     it "only shows the first eleven lines of the response" do
-      error = generate_error_with_backtrace @request, @response
-      error.to_s.should match(/line 1\n.+line 11\n\n/m)
+      expect(subject).to match(/line 1\n.+line 11\n\n/m)
     end
 
-    it "shows only one line when the response is one line long" do
-      @response[:body] = "<pre>failed</pre>"
-
-      error = generate_error_with_backtrace @request, @response
-      error.to_s.should match(/Error: failed/)
+    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
-    before do
-      response_lines = (1..15).to_a.map { |i| "line #{i}" }
-
-      @request  = mock :[] => "mocked"
-      @response = {
-        :body   => response_lines.join("\n"),
-        :status => 400
-      }
-    end
 
     it "only shows the first eleven lines of the response" do
-      error = generate_error_with_backtrace @request, @response
-      error.to_s.should match(/line 1\n.+line 11\n\n/m)
+      expect(subject).to match(/line 1\n.+line 11\n\n/m)
     end
 
-    it "shows only one line when the response is one line long" do
-      @response[:body] = "failed"
-
-      error = generate_error_with_backtrace @request, @response
-      error.to_s.should match(/Error: failed/)
+    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
   end
 end

data/spec/api/pagination_spec.rb

@@ -6,16 +6,23 @@ describe "RSolr::Pagination" do
       r = c.build_paginated_request 3, 25, "select", {:params => {:q => "test"}}
       #r[:page].should == 3
       #r[:per_page].should == 25
-      r[:params]["start"].should == 50
-      r[:params]["rows"].should == 25
-      r[:uri].query.should =~ /rows=25/
-      r[:uri].query.should =~ /start=50/
+      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
+
+    it 'passes through client options' do
+      c = RSolr::Client.new(nil, open_timeout: 5, read_timeout: 7)
+      r = c.build_paginated_request 3, 25, "select", {:params => {:q => "test"}}
+      expect(r[:open_timeout]).to eq(5)
+      expect(r[:read_timeout]).to eq(7)
     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)
-      c.should_receive(:execute).with(hash_including({
+      expect(c).to receive(:execute).with(hash_including({
         #:page => 1,
         #:per_page => 10,
         :params => {

data/spec/api/rsolr_spec.rb

@@ -2,18 +2,38 @@ require 'spec_helper'
 describe "RSolr" do
   
   it "has a version that can be read via #version or VERSION" do
-    RSolr.version.should == RSolr::VERSION
+    expect(RSolr.version).to eq(RSolr::VERSION)
   end
-  
-  it "can escape" do
-    RSolr.should be_a(RSolr::Char)
-    RSolr.escape("this string").should == "this\\ string"
-  end
-  
+
   context "connect" do
     it "should return a RSolr::Client instance" do
-      RSolr.connect.should be_a(RSolr::Client)
+      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
+
+  # deprecated as of 2015-02
+=begin
+  it "can escape" do
+    expect(RSolr).to be_a(RSolr::Char)
+    expect(RSolr.escape("this string")).to eq("this\\ string")
+  end
+=end
   
 end

data/spec/api/uri_spec.rb

@@ -1,70 +1,128 @@
 require 'spec_helper'
 describe "RSolr::Uri" do
   
-  context "class-level methods" do
-    
-    let(:uri){ RSolr::Uri }
-    
-    it "should return a URI object with a trailing slash" do
+  let(:uri) { RSolr::Uri }
+  
+  context '.create' do
+    it "returns a URI object" do
       u = uri.create 'http://apache.org'
-      u.path[0].should == ?/
+      expect(u).to be_a_kind_of URI
     end
-  
-    it "should return the bytesize of a string" do
-      uri.bytesize("test").should == 4
+    it "calls URI.parse" do
+      expect(URI).to receive(:parse).twice.and_call_original
+      u = uri.create 'http://apache.org'
     end
-  
-    it "should convert a solr query string from a hash w/o a starting ?" do
+    it "adds a trailing slash after host if there is none" do
+      u = uri.create 'http://apache.org'
+      u_str = u.to_s
+      size = u_str.size
+      expect(u_str[size - 1]).to eq '/'
+    end
+    it "does not add trailing slash after host if there already is one" do
+      u = uri.create 'http://apache.org/'
+      u_str = u.to_s
+      size = u_str.size
+      expect(u_str[size - 2, 2]).to eq 'g/'
+    end
+    it "adds a trailing slash after path if there is none" do
+      u = uri.create 'http://apache.org/lucene'
+      u_str = u.to_s
+      size = u_str.size
+      expect(u_str[size - 1]).to eq '/'
+    end
+    it "does not add trailing slash after path if there already is one" do
+      u = uri.create 'http://apache.org/lucene/'
+      u_str = u.to_s
+      size = u_str.size
+      expect(u_str[size - 2, 2]).to eq 'e/'
+    end
+    it "does not add trailing slash if there are query params" do
+      u = uri.create 'http://apache.org?foo=bar'
+      u_str = u.to_s
+      size = u_str.size
+      expect(u_str[size - 1]).not_to eq '/'
+    end
+  end
+
+  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
-      query[0].should_not == ??
+      expect(query[0]).not_to eq(??)
       [/q=gold/, /fq=mode%3Aone/, /fq=level%3A2/].each do |p|
-        query.should match p
+        expect(query).to match p
       end
-      query.split('&').size.should == 3
+      expect(query.split('&').size).to eq(3)
+    end
+    it 'should URL escape &' do
+      expect(uri.params_to_solr(:fq => "&")).to eq('fq=%26')
     end
-    
-    context "escape_query_value" do
-      
-      it 'should escape &' do
-        uri.params_to_solr(:fq => "&").should == 'fq=%26'
-      end
 
-      it 'should convert spaces to +' do
-        uri.params_to_solr(:fq => "me and you").should == 'fq=me+and+you'
-      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 escape comlex 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'
-        uri.params_to_solr(my_params).should == expected
-      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 escape complex queries, part 2' do
-        my_params = {'q' => '+popularity:[10 TO *] +section:0'}
-        expected = 'q=%2Bpopularity%3A%5B10+TO+%2A%5D+%2Bsection%3A0'
-        uri.params_to_solr(my_params).should == expected
-      end
-      
-      it 'should escape properly' do
-        uri.escape_query_value('+').should == '%2B'
-        uri.escape_query_value('This is a test').should == 'This+is+a+test'
-        uri.escape_query_value('<>/\\').should == '%3C%3E%2F%5C'
-        uri.escape_query_value('"').should == '%22'
-        uri.escape_query_value(':').should == '%3A'
-      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
+  
+=begin
+  # deprecated
+  context '.build_param' do
+    it "calls URI.encode_www_form_component by default" do
+      expect(URI).to receive(:encode_www_form_component).twice
+      uri.build_param("foo", "bar")
+    end
+    it "calls URI.encode_www_form_component if escape arg = true" do
+      expect(URI).to receive(:encode_www_form_component).twice
+      uri.build_param("foo", "bar", true)
+    end
+    it "doesn't call URI.encode_www_form_component if escape arg = false" do
+      expect(URI).not_to receive(:encode_www_form_component)
+      uri.build_param("foo", "bar", false)
+    end
+  end
 
-      it 'should escape brackets' do
-        uri.escape_query_value('{').should == '%7B'
-        uri.escape_query_value('}').should == '%7D'
-      end
+  # deprecated
+  context ".escape_query_value" do
+    it 'should escape properly' do
+      expect(uri.escape_query_value('+')).to eq('%2B')
+      expect(uri.escape_query_value('This is a test')).to eq('This+is+a+test')
+      expect(uri.escape_query_value('<>/\\')).to eq('%3C%3E%2F%5C')
+      expect(uri.escape_query_value('"')).to eq('%22')
+      expect(uri.escape_query_value(':')).to eq('%3A')
+    end
 
-      it 'should escape exclamation marks!' do
-        uri.escape_query_value('!').should == '%21'
-      end
-      
+    it 'should escape brackets' do
+      expect(uri.escape_query_value('{')).to eq('%7B')
+      expect(uri.escape_query_value('}')).to eq('%7D')
+    end
+
+    it 'should escape exclamation marks!' do
+      expect(uri.escape_query_value('!')).to eq('%21')
     end
-    
   end
   
+  # deprecated
+  context '.bytesize' do
+    it "calls .bytesize for String" do
+      str = "testing"
+      expect(str).to receive(:bytesize)
+      uri.bytesize(str)
+    end
+    it "returns the size of a String" do
+      expect(uri.bytesize("test")).to eq(4)
+    end
+  end
+=end
+
 end