rsolr 1.1.2 → 2.0.0.pre1

data/spec/api/pagination_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
-describe "RSolr::Pagination" do
+
+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)
@@ -11,13 +12,6 @@ describe "RSolr::Pagination" do
       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
@@ -28,7 +22,7 @@ describe "RSolr::Pagination" do
         :params => {
           "rows" => 10,
           "start" => 0,
-          :wt => :ruby
+          :wt => :json
         }
       }))
       c.paginate 1, 10, "select"

data/spec/api/rsolr_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
-describe "RSolr" do
+
+RSpec.describe RSolr do
   
   it "has a version that can be read via #version or VERSION" do
     expect(RSolr.version).to eq(RSolr::VERSION)
@@ -27,13 +28,4 @@ describe "RSolr" do
       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
+end

data/spec/api/uri_spec.rb

@@ -1,48 +1,8 @@
 require 'spec_helper'
-describe "RSolr::Uri" do
+
+RSpec.describe RSolr::Uri do
   
   let(:uri) { RSolr::Uri }
-  
-  context '.create' do
-    it "returns a URI object" do
-      u = uri.create 'http://apache.org'
-      expect(u).to be_a_kind_of URI
-    end
-    it "calls URI.parse" do
-      expect(URI).to receive(:parse).twice.and_call_original
-      u = uri.create 'http://apache.org'
-    end
-    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
@@ -74,55 +34,4 @@ describe "RSolr::Uri" do
       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
-
-  # 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 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

data/spec/api/xml_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 require 'builder'
 require 'nokogiri'
-describe "RSolr::Xml" do
-  
+
+RSpec.describe RSolr::Xml do
   let(:generator){ RSolr::Xml::Generator.new }
 
   builder_engines = { 
@@ -52,8 +52,6 @@ describe "RSolr::Xml" do
           add_attrs = {:boost=>200.00}
           result = generator.add(documents, add_attrs) do |doc|
             doc.field_by_name(:name).attrs[:boost] = 10
-            expect(doc.fields.size).to eq(4)
-            expect(doc.fields_by_name(:cat).size).to eq(2)
           end
           expect(result).to match(%r(name="cat">cat 1</field>))
           expect(result).to match(%r(name="cat">cat 2</field>))
@@ -81,6 +79,17 @@ describe "RSolr::Xml" do
           expect(result).to match(/<field name="id">1<\/field>/)
         end
 
+        # add a single hash ("doc")
+        it 'should create an add from a hash formatted for atomic updates' do
+          data = {
+            :id=>1,
+            :name=> { set: 'matt' }
+          }
+          result = generator.add(data)
+          expect(result).to match(/<field name="name" update="set">matt<\/field>/)
+          expect(result).to match(/<field name="id">1<\/field>/)
+        end
+
         # add an array of hashes
         it 'should create many adds from an array of hashes' do
           data = [
@@ -95,8 +104,8 @@ describe "RSolr::Xml" do
           ]
           message = generator.add(data)
           expected = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><add><doc><field name=\"id\">1</field><field name=\"name\">matt</field></doc><doc><field name=\"id\">2</field><field name=\"name\">sam</field></doc></add>"
-          expect(message).to match(/<field name="name">matt<\/field>/)
-          expect(message).to match(/<field name="name">sam<\/field>/)
+          expect(message).to match %r{<field name="name">matt</field>}
+          expect(message).to match %r{<field name="name">sam</field>}
         end
 
         # multiValue field support test, thanks to Fouad Mardini!
@@ -122,7 +131,7 @@ describe "RSolr::Xml" do
         end
 
         it 'should create an add from a single Message::Document' do
-          document = RSolr::Xml::Document.new
+          document = RSolr::Document.new
           document.add_field('id', 1)
           document.add_field('name', 'matt', :boost => 2.0)
           result = generator.add(document)
@@ -135,7 +144,7 @@ describe "RSolr::Xml" do
     
         it 'should create adds from multiple Message::Documents' do
           documents = (1..2).map do |i|
-            doc = RSolr::Xml::Document.new
+            doc = RSolr::Document.new
             doc.add_field('id', i)
             doc.add_field('name', "matt#{i}")
             doc
@@ -144,7 +153,24 @@ describe "RSolr::Xml" do
           expect(result).to match(/<field name="name">matt1<\/field>/)
           expect(result).to match(/<field name="name">matt2<\/field>/)
         end
-    
+
+        it 'supports nested child documents' do
+          data = {
+            :_childDocuments_ => [
+              {
+                :id => 1
+              },
+              {
+                :id => 2
+              }
+            ]
+          }
+
+          result = generator.add(data)
+          expect(result).to match(%r{<add><doc><doc>})
+          expect(result).to match(%r{<doc><field name="id">1</field></doc>})
+          expect(result).to match(%r{<doc><field name="id">2</field></doc>})
+        end
       end
   
       context :delete_by_id do
@@ -217,5 +243,5 @@ describe "RSolr::Xml" do
         expect(result).to match(/<field name="whatever">some string<\/field>/)
       end
     end
-  end
+  end  
 end

data/spec/integration/solr5_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'solr_wrapper'
 
-describe "Solr basic_configs" do
+RSpec.describe "Solr basic_configs" do
   SOLR_INSTANCE =  SolrWrapper.default_instance({})
   before(:all) { SOLR_INSTANCE.start }
   after(:all) { SOLR_INSTANCE.stop }

data/spec/spec_helper.rb

@@ -3,6 +3,87 @@ require 'rspec'
 
 FIXTURES_DIR = File.expand_path("fixtures", File.dirname(__FILE__))
 
-RSpec.configure do |c|
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
 
-end
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rsolr
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0.pre1
 platform: ruby
 authors:
 - Antoine Latter
@@ -29,7 +29,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-19 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: builder
@@ -45,6 +45,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.1.2
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -138,6 +152,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
 - ".travis.yml"
 - CHANGES.txt
 - Gemfile
@@ -147,17 +162,18 @@ files:
 - lib/rsolr.rb
 - lib/rsolr/char.rb
 - lib/rsolr/client.rb
-- lib/rsolr/connection.rb
+- lib/rsolr/document.rb
 - lib/rsolr/error.rb
+- lib/rsolr/json.rb
 - lib/rsolr/response.rb
 - lib/rsolr/uri.rb
 - lib/rsolr/version.rb
 - lib/rsolr/xml.rb
 - rsolr.gemspec
-- spec/api/char_spec.rb
 - spec/api/client_spec.rb
-- spec/api/connection_spec.rb
+- spec/api/document_spec.rb
 - spec/api/error_spec.rb
+- spec/api/json_spec.rb
 - spec/api/pagination_spec.rb
 - spec/api/rsolr_spec.rb
 - spec/api/uri_spec.rb
@@ -172,9 +188,6 @@ files:
 - spec/fixtures/basic_configs/synonyms.txt
 - spec/integration/solr5_spec.rb
 - spec/spec_helper.rb
-- tasks/rdoc.rake
-- tasks/rsolr.rake
-- tasks/spec.rake
 homepage: https://github.com/rsolr/rsolr
 licenses:
 - Apache-2.0
@@ -190,9 +203,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: rsolr
 rubygems_version: 2.5.1

data/lib/rsolr/connection.rb

@@ -1,74 +0,0 @@
-require 'net/http'
-require 'net/https'
-
-# The default/Net::Http adapter for RSolr.
-class RSolr::Connection
-
-  # using the request_context hash,
-  # send a request,
-  # then return the standard rsolr response hash {:status, :body, :headers}
-  def execute client, request_context
-    h = http request_context[:uri], request_context[:proxy], request_context[:read_timeout], request_context[:open_timeout]
-    request = setup_raw_request request_context
-    request.body = request_context[:data] if request_context[:method] == :post and request_context[:data]
-    begin
-      response = h.request request
-      charset = response.type_params["charset"]
-      {:status => response.code.to_i, :headers => response.to_hash, :body => force_charset(response.body, charset)}
-    rescue Errno::ECONNREFUSED
-      raise RSolr::Error::ConnectionRefused, request_context.inspect
-    # catch the undefined closed? exception -- this is a confirmed ruby bug
-    rescue NoMethodError => e
-      e.message == "undefined method `closed?' for nil:NilClass" ?
-        raise(RSolr::Error::ConnectionRefused, request_context.inspect) :
-        raise(e)
-    end
-  end
-
-  protected
-
-  # This returns a singleton of a Net::HTTP or Net::HTTP.Proxy request object.
-  def http uri, proxy = nil, read_timeout = nil, open_timeout = nil
-    http = if proxy
-      proxy_user, proxy_pass = proxy.userinfo.split(/:/) if proxy.userinfo
-      Net::HTTP.Proxy(proxy.host, proxy.port, proxy_user, proxy_pass).new uri.host, uri.port
-    elsif proxy == false
-      # If explicitly passing in false, make sure we set proxy_addr to nil
-      # to tell Net::HTTP to *not* use the environment proxy variables.
-      Net::HTTP.new uri.host, uri.port, nil
-    else
-      Net::HTTP.new uri.host, uri.port
-    end
-    http.use_ssl = uri.port == 443 || uri.instance_of?(URI::HTTPS)
-    http.read_timeout = read_timeout if read_timeout
-    http.open_timeout = open_timeout if open_timeout
-    http
-  end
-
-  #
-  def setup_raw_request request_context
-    http_method = case request_context[:method]
-    when :get
-      Net::HTTP::Get
-    when :post
-      Net::HTTP::Post
-    when :head
-      Net::HTTP::Head
-    else
-      raise "Only :get, :post and :head http method types are allowed."
-    end
-    headers = request_context[:headers] || {}
-    raw_request = http_method.new request_context[:uri].request_uri
-    raw_request.initialize_http_header headers
-    raw_request.basic_auth(request_context[:uri].user, request_context[:uri].password) if request_context[:uri].user && request_context[:uri].password
-    raw_request
-  end
-
-  private
-
-  def force_charset body, charset
-    return body unless charset and body.respond_to?(:force_encoding)
-    body.force_encoding(charset)
-  end
-
-end

data/spec/api/char_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-# @deprecated remove this module's specs when we remove the method (duh)
-describe "RSolr::Char" do
-  
-  let(:char){Object.new.extend RSolr::Char}
-  
-  # deprecated as of 2015-02, as it is incorrect Solr escaping.
-  #  instead, use RSolr.solr_escape
-  #  commented out as it gives a mess of deprecation warnings
-=begin  
-  it 'should escape everything that is not a word with \\' do
-    (0..255).each do |ascii|
-      chr = ascii.chr
-      esc = char.escape(chr)
-      if chr =~ /\W/
-        expect(esc.to_s).to eq("\\#{chr}")
-      else
-        expect(esc.to_s).to eq(chr)
-      end
-    end
-  end
-=end  
-end

data/spec/api/connection_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-require 'base64'
-
-describe "RSolr::Connection" do
-
-  context "setup_raw_request" do
-    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) { double.as_null_object }
-
-    let(:http) { double(Net::HTTP).as_null_object }
-
-    subject { RSolr::Connection.new }
-
-    before do
-      allow(Net::HTTP).to receive(:new) { http }
-    end
-
-    it "should configure Net:HTTP read_timeout" do
-      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
-      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) { double.as_null_object }
-
-    let(:http) { double(Net::HTTP).as_null_object }
-
-    subject { RSolr::Connection.new }
-
-    before do
-      allow(Net::HTTP).to receive(:new) { http }
-    end
-
-    it "should configure Net:HTTP open_timeout" do
-      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
-      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) { double(Net::HTTP).as_null_object }
-
-    before do
-      allow(Net::HTTP).to receive(:new) { http }
-    end
-
-    it "sets the authorization header" do
-      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
-  end
-end