rsolr 1.0.10 → 1.0.11

data/spec/api/client_spec.rb

@@ -12,7 +12,7 @@ describe "RSolr::Client" do
   
   context "initialize" do
     it "should accept whatevs and set it as the @connection" do
-      RSolr::Client.new(:whatevs).connection.should == :whatevs
+      expect(RSolr::Client.new(:whatevs).connection).to eq(:whatevs)
     end
   end
   
@@ -20,7 +20,7 @@ describe "RSolr::Client" do
     include ClientHelper
     it "should forward these method calls the #connection object" do
       [:get, :post, :head].each do |meth|
-        client.connection.should_receive(:execute).
+        expect(client.connection).to receive(:execute).
             and_return({:status => 200, :body => "{}", :headers => {}})
         client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
       end
@@ -28,7 +28,7 @@ describe "RSolr::Client" do
 
     it "should be timeout aware" do
       [:get, :post, :head].each do |meth|
-        client.connection.should_receive(:execute).with(client, hash_including(:read_timeout => 42, :open_timeout=>43))
+        expect(client.connection).to receive(:execute).with(client, hash_including(:read_timeout => 42, :open_timeout=>43))
         client.send_and_receive '', :method => meth, :params => {}, :data => nil, :headers => {}
       end
     end
@@ -48,21 +48,21 @@ describe "RSolr::Client" do
       }
     end
     it "should retry 503s if requested" do
-      client.connection.should_receive(:execute).exactly(2).times.and_return(
+      expect(client.connection).to receive(:execute).exactly(2).times.and_return(
         {:status => 503, :body => "{}", :headers => {'Retry-After' => 0}},
         {:status => 200, :body => "{}", :headers => {}}
       )
       client.execute request_context
     end
     it "should not retry a 503 if the retry-after is too large" do
-      client.connection.should_receive(:execute).exactly(1).times.and_return(
+      expect(client.connection).to receive(:execute).exactly(1).times.and_return(
         {:status => 503, :body => "{}", :headers => {'Retry-After' => 10}}
       )
-      lambda {
+      expect {
         Timeout.timeout(0.5) do
           client.execute({:retry_after_limit => 0}.merge(request_context))
         end
-      }.should raise_error(RSolr::Error::Http)
+      }.to raise_error(RSolr::Error::Http)
     end
   end
 
@@ -70,7 +70,7 @@ describe "RSolr::Client" do
     include ClientHelper
     it "should pass the expected params to the connection's #execute method" do
       request_opts = {:data => "the data", :method=>:post, :headers => {"Content-Type" => "text/plain"}}
-      client.connection.should_receive(:execute).
+      expect(client.connection).to receive(:execute).
         with(client, hash_including(request_opts)).
         and_return(
           :body => "",
@@ -84,14 +84,14 @@ describe "RSolr::Client" do
   context "xml" do
     include ClientHelper
     it "should return an instance of RSolr::Xml::Generator" do
-      client.xml.should be_a RSolr::Xml::Generator
+      expect(client.xml).to be_a RSolr::Xml::Generator
     end
   end
   
   context "add" do
     include ClientHelper
     it "should send xml to the connection's #post method" do
-      client.connection.should_receive(:execute).
+      expect(client.connection).to receive(:execute).
         with(
           client, hash_including({
             :path => "update",
@@ -105,7 +105,7 @@ describe "RSolr::Client" do
             :status => 200,
             :headers => {"Content-Type"=>"text/xml"}
           )
-      client.xml.should_receive(:add).
+      expect(client.xml).to receive(:add).
         with({:id=>1}, {:commitWith=>10}).
           and_return("<xml/>")
       client.add({:id=>1}, :add_attributes => {:commitWith=>10})
@@ -115,7 +115,7 @@ describe "RSolr::Client" do
   context "update" do
     include ClientHelper
     it "should send data to the connection's #post method" do
-      client.connection.should_receive(:execute).
+      expect(client.connection).to receive(:execute).
         with(
           client, hash_including({
             :path => "update",
@@ -137,7 +137,7 @@ describe "RSolr::Client" do
     include ClientHelper
     [:commit, :optimize, :rollback].each do |meth|
       it "should send a #{meth} message to the connection's #post method" do
-        client.connection.should_receive(:execute).
+        expect(client.connection).to receive(:execute).
           with(
             client, hash_including({
               :path => "update",
@@ -159,7 +159,7 @@ describe "RSolr::Client" do
   context "delete_by_id" do
     include ClientHelper
     it "should send data to the connection's #post method" do
-      client.connection.should_receive(:execute).
+      expect(client.connection).to receive(:execute).
         with(
           client, hash_including({
             :path => "update",
@@ -180,7 +180,7 @@ describe "RSolr::Client" do
   context "delete_by_query" do
     include ClientHelper
     it "should send data to the connection's #post method" do
-      client.connection.should_receive(:execute).
+      expect(client.connection).to receive(:execute).
         with(
           client, hash_including({
             :path => "update",
@@ -203,42 +203,41 @@ describe "RSolr::Client" do
     it 'should not try to evaluate ruby when the :qt is not :ruby' do
       body = '{:time=>"NOW"}'
       result = client.adapt_response({:params=>{}}, {:status => 200, :body => body, :headers => {}})
-      result.should == body
+      expect(result).to eq(body)
     end
     
     it 'should evaluate ruby responses when the :wt is :ruby' do
       body = '{:time=>"NOW"}'
       result = client.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
-      result.should == {:time=>"NOW"}
+      expect(result).to eq({:time=>"NOW"})
     end
     
     it 'should evaluate json responses when the :wt is :json' do
       body = '{"time": "NOW"}'
       result = client.adapt_response({:params=>{:wt=>:json}}, {:status => 200, :body => body, :headers => {}})
       if defined? JSON
-        result.should == {:time=>"NOW"}
+        expect(result).to eq({:time=>"NOW"})
       else
         # ruby 1.8 without the JSON gem
-        result.should == '{"time": "NOW"}'
+        expect(result).to eq('{"time": "NOW"}')
       end
     end
 
     it "ought raise a RSolr::Error::InvalidRubyResponse when the ruby is indeed frugged, or even fruggified" do
-      lambda {
+      expect {
         client.adapt_response({:params=>{:wt => :ruby}}, {:status => 200, :body => "<woops/>", :headers => {}})
-      }.should raise_error RSolr::Error::InvalidRubyResponse
+      }.to raise_error RSolr::Error::InvalidRubyResponse
     end
   
   end
   
   context "indifferent access" do
     include ClientHelper
-    it "should raise a NoMethodError if the #with_indifferent_access extension isn't loaded" do
-      # TODO: Find a less implmentation-tied way to test this
-      Hash.any_instance.should_receive(:respond_to?).with(:with_indifferent_access).and_return(false)
+    it "should raise a RuntimeError if the #with_indifferent_access extension isn't loaded" do
+      hide_const("HashWithIndifferentAccess")
       body = "{'foo'=>'bar'}"
       result = client.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
-      lambda { result.with_indifferent_access }.should raise_error NoMethodError
+      expect { result.with_indifferent_access }.to raise_error RuntimeError
     end
 
     it "should provide indifferent access" do
@@ -247,13 +246,13 @@ describe "RSolr::Client" do
       result = client.adapt_response({:params=>{:wt=>:ruby}}, {:status => 200, :body => body, :headers => {}})
       indifferent_result = result.with_indifferent_access
 
-      result.should be_a(RSolr::Response)
-      result['foo'].should == 'bar'
-      result[:foo].should be_nil
+      expect(result).to be_a(RSolr::Response)
+      expect(result['foo']).to eq('bar')
+      expect(result[:foo]).to be_nil
 
-      indifferent_result.should be_a(RSolr::Response)
-      indifferent_result['foo'].should == 'bar'
-      indifferent_result[:foo].should == 'bar'
+      expect(indifferent_result).to be_a(RSolr::Response)
+      expect(indifferent_result['foo']).to eq('bar')
+      expect(indifferent_result[:foo]).to eq('bar')
     end
   end
 
@@ -267,10 +266,10 @@ describe "RSolr::Client" do
         :headers => {}
       )
       [/fq=0/, /fq=1/, /q=test/, /wt=ruby/].each do |pattern|
-        result[:query].should match pattern
+        expect(result[:query]).to match pattern
       end
-      result[:data].should == "data"
-      result[:headers].should == {}
+      expect(result[:data]).to eq("data")
+      expect(result[:headers]).to eq({})
     end
     
     it "should set the Content-Type header to application/x-www-form-urlencoded; charset=UTF-8 if a hash is passed in to the data arg" do
@@ -279,12 +278,12 @@ describe "RSolr::Client" do
         :data => {:q=>'test', :fq=>[0,1]},
         :headers => {}
       )
-      result[:query].should == "wt=ruby"
+      expect(result[:query]).to eq("wt=ruby")
       [/fq=0/, /fq=1/, /q=test/].each do |pattern|
-        result[:data].should match pattern
+        expect(result[:data]).to match pattern
       end
-      result[:data].should_not match /wt=ruby/
-      result[:headers].should == {"Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8"}
+      expect(result[:data]).not_to match /wt=ruby/
+      expect(result[:headers]).to eq({"Content-Type" => "application/x-www-form-urlencoded; charset=UTF-8"})
     end
     
   end

data/spec/api/connection_spec.rb

@@ -4,93 +4,95 @@ 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 "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 } 
 
     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 } 
 
     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 "connection refused" 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 }
     let(:request_context) {
       {:uri => URI.parse("http://localhost/some_uri"), :method => :get, :open_timeout => 42}
     }
     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
-      pending "doesn't work with ruby 1.8" if RUBY_VERSION < "1.9"
-      http.should_receive(:request).and_raise(Errno::ECONNREFUSED)
-      lambda {
+      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
-      }.should raise_error(Errno::ECONNREFUSED, /#{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

@@ -10,7 +10,7 @@ describe "RSolr::Error" do
     before do
       response_lines = (1..15).to_a.map { |i| "line #{i}" }
 
-      @request  = mock :[] => "mocked"
+      @request  = double :[] => "mocked"
       @response = {
         :body   => "<pre>" + response_lines.join("\n") + "</pre>",
         :status => 400
@@ -19,14 +19,14 @@ describe "RSolr::Error" do
 
     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(error.to_s).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/)
+      expect(error.to_s).to match(/Error: failed/)
     end
   end
 
@@ -34,7 +34,7 @@ describe "RSolr::Error" do
     before do
       response_lines = (1..15).to_a.map { |i| "line #{i}" }
 
-      @request  = mock :[] => "mocked"
+      @request  = double :[] => "mocked"
       @response = {
         :body   => response_lines.join("\n"),
         :status => 400
@@ -43,14 +43,14 @@ describe "RSolr::Error" do
 
     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(error.to_s).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/)
+      expect(error.to_s).to match(/Error: failed/)
     end
   end
 end

data/spec/api/pagination_spec.rb

@@ -6,16 +6,16 @@ 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
   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