rest-client 1.6.7 → 1.8.0

data/spec/{exceptions_spec.rb → unit/exceptions_spec.rb}

@@ -1,23 +1,20 @@
-require File.join( File.dirname(File.expand_path(__FILE__)), 'base')
-
-require 'webmock/rspec'
-include WebMock
+require 'spec_helper'
 
 describe RestClient::Exception do
   it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
     e = RestClient::Exception.new
-    e.message.should == "RestClient::Exception"
+    e.message.should eq "RestClient::Exception"
   end
-  
+
   it "returns the 'message' that was set" do
     e = RestClient::Exception.new
     message = "An explicitly set message"
     e.message = message
-    e.message.should == message
+    e.message.should eq message
   end
-  
+
   it "sets the exception message to ErrorMessage" do
-    RestClient::ResourceNotFound.new.message.should == 'Resource Not Found'
+    RestClient::ResourceNotFound.new.message.should eq 'Resource Not Found'
   end
 
   it "contains exceptions in RestClient" do
@@ -29,13 +26,13 @@ end
 describe RestClient::ServerBrokeConnection do
   it "should have a default message of 'Server broke connection'" do
     e = RestClient::ServerBrokeConnection.new
-    e.message.should == 'Server broke connection'
+    e.message.should eq 'Server broke connection'
   end
 end
 
 describe RestClient::RequestFailed do
   before do
-    @response = mock('HTTP Response', :code => '502')
+    @response = double('HTTP Response', :code => '502')
   end
 
   it "stores the http response on the exception" do
@@ -43,17 +40,17 @@ describe RestClient::RequestFailed do
     begin
       raise RestClient::RequestFailed, response
     rescue RestClient::RequestFailed => e
-      e.response.should == response
+      e.response.should eq response
     end
   end
 
   it "http_code convenience method for fetching the code as an integer" do
-    RestClient::RequestFailed.new(@response).http_code.should == 502
+    RestClient::RequestFailed.new(@response).http_code.should eq 502
   end
 
   it "http_body convenience method for fetching the body (decoding when necessary)" do
-    RestClient::RequestFailed.new(@response).http_code.should == 502
-    RestClient::RequestFailed.new(@response).message.should == 'HTTP status code 502'
+    RestClient::RequestFailed.new(@response).http_code.should eq 502
+    RestClient::RequestFailed.new(@response).message.should eq 'HTTP status code 502'
   end
 
   it "shows the status code in the message" do
@@ -67,22 +64,22 @@ describe RestClient::ResourceNotFound do
     begin
       raise RestClient::ResourceNotFound, response
     rescue RestClient::ResourceNotFound => e
-      e.response.should == response
+      e.response.should eq response
     end
   end
 end
 
 describe "backwards compatibility" do
   it "alias RestClient::Request::Redirect to RestClient::Redirect" do
-    RestClient::Request::Redirect.should == RestClient::Redirect
+    RestClient::Request::Redirect.should eq RestClient::Redirect
   end
 
   it "alias RestClient::Request::Unauthorized to RestClient::Unauthorized" do
-    RestClient::Request::Unauthorized.should == RestClient::Unauthorized
+    RestClient::Request::Unauthorized.should eq RestClient::Unauthorized
   end
 
   it "alias RestClient::Request::RequestFailed to RestClient::RequestFailed" do
-    RestClient::Request::RequestFailed.should == RestClient::RequestFailed
+    RestClient::Request::RequestFailed.should eq RestClient::RequestFailed
   end
 
   it "make the exception's response act like an Net::HTTPResponse" do
@@ -92,7 +89,7 @@ describe "backwards compatibility" do
       RestClient.get "www.example.com"
       raise
     rescue RestClient::ResourceNotFound => e
-      e.response.body.should == body
+      e.response.body.should eq body
     end
   end
 end

data/spec/{payload_spec.rb → unit/payload_spec.rb}

@@ -1,29 +1,31 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'base')
+# encoding: binary
+
+require 'spec_helper'
 
 describe RestClient::Payload do
   context "A regular Payload" do
     it "should use standard enctype as default content-type" do
       RestClient::Payload::UrlEncoded.new({}).headers['Content-Type'].
-          should == 'application/x-www-form-urlencoded'
+          should eq 'application/x-www-form-urlencoded'
     end
 
     it "should form properly encoded params" do
       RestClient::Payload::UrlEncoded.new({:foo => 'bar'}).to_s.
-          should == "foo=bar"
+          should eq "foo=bar"
       ["foo=bar&baz=qux", "baz=qux&foo=bar"].should include(
                                                         RestClient::Payload::UrlEncoded.new({:foo => 'bar', :baz => 'qux'}).to_s)
     end
 
     it "should escape parameters" do
       RestClient::Payload::UrlEncoded.new({'foo ' => 'bar'}).to_s.
-          should == "foo%20=bar"
+          should eq "foo%20=bar"
     end
 
     it "should properly handle hashes as parameter" do
       RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz'}}).to_s.
-          should == "foo[bar]=baz"
+          should eq "foo[bar]=baz"
       RestClient::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux'}}}).to_s.
-          should == "foo[bar][baz]=qux"
+          should eq "foo[bar][baz]=qux"
     end
 
     it "should handle many attributes inside a hash" do
@@ -43,18 +45,18 @@ describe RestClient::Payload do
 
     it "should form properly use symbols as parameters" do
       RestClient::Payload::UrlEncoded.new({:foo => :bar}).to_s.
-          should == "foo=bar"
+          should eq "foo=bar"
       RestClient::Payload::UrlEncoded.new({:foo => {:bar => :baz}}).to_s.
-          should == "foo[bar]=baz"
+          should eq "foo[bar]=baz"
     end
 
     it "should properly handle arrays as repeated parameters" do
       RestClient::Payload::UrlEncoded.new({:foo => ['bar']}).to_s.
-          should == "foo[]=bar"
+          should eq "foo[]=bar"
       RestClient::Payload::UrlEncoded.new({:foo => ['bar', 'baz']}).to_s.
-          should == "foo[]=bar&foo[]=baz"
+          should eq "foo[]=bar&foo[]=baz"
     end
-    
+
     it 'should not close if stream already closed' do
       p = RestClient::Payload::UrlEncoded.new({'foo ' => 'bar'})
       3.times {p.close}
@@ -65,10 +67,10 @@ describe RestClient::Payload do
   context "A multipart Payload" do
     it "should use standard enctype as default content-type" do
       m = RestClient::Payload::Multipart.new({})
-      m.stub!(:boundary).and_return(123)
-      m.headers['Content-Type'].should == 'multipart/form-data; boundary=123'
+      m.stub(:boundary).and_return(123)
+      m.headers['Content-Type'].should eq 'multipart/form-data; boundary=123'
     end
-    
+
     it 'should not error on close if stream already closed' do
       m = RestClient::Payload::Multipart.new(:file => File.new(File.join(File.dirname(File.expand_path(__FILE__)), 'master_shake.jpg')))
       3.times {m.close}
@@ -76,7 +78,7 @@ describe RestClient::Payload do
 
     it "should form properly separated multipart data" do
       m = RestClient::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="bar"\r
 \r
@@ -91,7 +93,7 @@ bar\r
 
     it "should not escape parameters names" do
       m = RestClient::Payload::Multipart.new([["bar ", "baz"]])
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="bar "\r
 \r
@@ -103,12 +105,12 @@ baz\r
     it "should form properly separated multipart data" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
       m = RestClient::Payload::Multipart.new({:foo => f})
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\r
 Content-Type: image/jpeg\r
 \r
-#{IO.read(f.path)}\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
 --#{m.boundary}--\r
       EOS
     end
@@ -116,12 +118,12 @@ Content-Type: image/jpeg\r
     it "should ignore the name attribute when it's not set" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
       m = RestClient::Payload::Multipart.new({nil => f})
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; filename="master_shake.jpg"\r
 Content-Type: image/jpeg\r
 \r
-#{IO.read(f.path)}\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
 --#{m.boundary}--\r
       EOS
     end
@@ -131,19 +133,19 @@ Content-Type: image/jpeg\r
       f.instance_eval "def content_type; 'text/plain'; end"
       f.instance_eval "def original_filename; 'foo.txt'; end"
       m = RestClient::Payload::Multipart.new({:foo => f})
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
 Content-Type: text/plain\r
 \r
-#{IO.read(f.path)}\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
 --#{m.boundary}--\r
       EOS
     end
 
     it "should handle hash in hash parameters" do
       m = RestClient::Payload::Multipart.new({:bar => {:baz => "foo"}})
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="bar[baz]"\r
 \r
@@ -155,12 +157,12 @@ foo\r
       f.instance_eval "def content_type; 'text/plain'; end"
       f.instance_eval "def original_filename; 'foo.txt'; end"
       m = RestClient::Payload::Multipart.new({:foo => {:bar => f}})
-      m.to_s.should == <<-EOS
+      m.to_s.should eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="foo[bar]"; filename="foo.txt"\r
 Content-Type: text/plain\r
 \r
-#{IO.read(f.path)}\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
 --#{m.boundary}--\r
       EOS
     end
@@ -171,23 +173,23 @@ Content-Type: text/plain\r
     it "should properly determine the size of file payloads" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
       payload = RestClient::Payload.generate(f)
-      payload.size.should == 22_545
-      payload.length.should == 22_545
+      payload.size.should eq 76_988
+      payload.length.should eq 76_988
     end
 
     it "should properly determine the size of other kinds of streaming payloads" do
       s = StringIO.new 'foo'
       payload = RestClient::Payload.generate(s)
-      payload.size.should == 3
-      payload.length.should == 3
+      payload.size.should eq 3
+      payload.length.should eq 3
 
       begin
         f = Tempfile.new "rest-client"
         f.write 'foo bar'
 
         payload = RestClient::Payload.generate(f)
-        payload.size.should == 7
-        payload.length.should == 7
+        payload.size.should eq 7
+        payload.length.should eq 7
       ensure
         f.close
       end
@@ -230,5 +232,14 @@ Content-Type: text/plain\r
     it "should recognize other payloads that can be streamed" do
       RestClient::Payload.generate(StringIO.new('foo')).should be_kind_of(RestClient::Payload::Streamed)
     end
+
+    # hashery gem introduces Hash#read convenience method. Existence of #read method used to determine of content is streameable :/
+    it "shouldn't treat hashes as streameable" do
+      RestClient::Payload.generate({"foo" => 'bar'}).should be_kind_of(RestClient::Payload::UrlEncoded)
+    end
+  end
+
+  class HashMapForTesting < Hash
+    alias :read :[]
   end
 end

data/spec/unit/raw_response_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe RestClient::RawResponse do
+  before do
+    @tf = double("Tempfile", :read => "the answer is 42", :open => true)
+    @net_http_res = double('net http response')
+    @request = double('http request')
+    @response = RestClient::RawResponse.new(@tf, @net_http_res, {}, @request)
+  end
+
+  it "behaves like string" do
+    @response.to_s.should eq 'the answer is 42'
+  end
+
+  it "exposes a Tempfile" do
+    @response.file.should eq @tf
+  end
+end

data/spec/{request2_spec.rb → unit/request2_spec.rb}

@@ -1,40 +1,32 @@
-require File.join( File.dirname(File.expand_path(__FILE__)), 'base')
-
-require 'webmock/rspec'
-include WebMock
+require 'spec_helper'
 
 describe RestClient::Request do
 
   it "manage params for get requests" do
     stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*; q=0.5, application/xml', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
-    RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}).body.should == 'foo'
+    RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}).body.should eq 'foo'
 
     stub_request(:get, 'http://some/resource').with(:headers => {'Accept'=>'*/*; q=0.5, application/xml', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar', 'params' => 'a'}).to_return(:body => 'foo', :status => 200)
-    RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => :a}).body.should == 'foo'
+    RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => :a}).body.should eq 'foo'
   end
 
   it "can use a block to process response" do
     response_value = nil
-    block = Proc.new do |http_response|
+    block = proc do |http_response|
       response_value = http_response.body
     end
     stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*; q=0.5, application/xml', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
     RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}, :block_response => block)
-    response_value.should == "foo"
+    response_value.should eq "foo"
   end
 
   it 'closes payload if not nil' do
     test_file = File.new(File.join( File.dirname(File.expand_path(__FILE__)), 'master_shake.jpg'))
-    initial_count = tmp_count
 
     stub_request(:post, 'http://some/resource').with(:headers => {'Accept'=>'*/*; q=0.5, application/xml', 'Accept-Encoding'=>'gzip, deflate'}).to_return(:body => 'foo', :status => 200)
     RestClient::Request.execute(:url => 'http://some/resource', :method => :post, :payload => {:file => test_file})
 
-    tmp_count.should == initial_count
+    test_file.closed?.should be_true
   end
 
 end
-
-def tmp_count
-  Dir.glob(Dir::tmpdir + "/*").size
-end