yajl-ruby 1.2.3 → 1.3.0

data/spec/global/global_spec.rb

@@ -3,52 +3,52 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper.rb')
 describe "Yajl" do
   context "dump" do
     it "should exist as a class-method" do
-      Yajl.should respond_to(:dump)
+      expect(Yajl).to respond_to(:dump)
     end
 
     it "should be able to encode to a string" do
-      Yajl.dump({:a => 1234}).should eql('{"a":1234}')
+      expect(Yajl.dump({:a => 1234})).to eql('{"a":1234}')
     end
 
     it "should be able to encode to an IO" do
       io = StringIO.new
       Yajl.dump({:a => 1234}, io)
       io.rewind
-      io.read.should eql('{"a":1234}')
+      expect(io.read).to eql('{"a":1234}')
     end
 
     it "should be able to encode with a block supplied" do
       Yajl.dump({:a => 1234}) do |chunk|
-        chunk.should eql('{"a":1234}')
+        expect(chunk).to eql('{"a":1234}')
       end
     end
   end
 
   context "load" do
     it "should exist as a class-method" do
-      Yajl.should respond_to(:load)
+      expect(Yajl).to respond_to(:load)
     end
 
     it "should be able to parse from a string" do
-      Yajl.load('{"a":1234}').should eql({"a" => 1234})
+      expect(Yajl.load('{"a":1234}')).to eql({"a" => 1234})
     end
 
     it "should be able to parse from an IO" do
       io = StringIO.new('{"a":1234}')
-      Yajl.load(io).should eql({"a" => 1234})
+      expect(Yajl.load(io)).to eql({"a" => 1234})
     end
 
     it "should be able to parse from a string with a block supplied" do
       Yajl.load('{"a":1234}') do |h|
-        h.should eql({"a" => 1234})
+        expect(h).to eql({"a" => 1234})
       end
     end
 
     it "should be able to parse from an IO with a block supplied" do
       io = StringIO.new('{"a":1234}')
       Yajl.load(io) do |h|
-        h.should eql({"a" => 1234})
+        expect(h).to eql({"a" => 1234})
       end
     end
   end
-end
+end

data/spec/http/http_delete_spec.rb

@@ -37,62 +37,62 @@ describe "Yajl HTTP DELETE request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.delete(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.delete(@uri)
+    expect(@template_hash).to eq(stream.delete(@uri))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :symbolize_keys => true))
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.delete(@uri)
+      expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.delete(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.delete(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.delete(@uri))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.delete(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.delete(@uri, :symbolize_keys => true))
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.delete(@uri) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.delete(@uri) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
-end
+end

data/spec/http/http_error_spec.rb

@@ -9,12 +9,11 @@ require 'yajl/deflate'
 require 'yajl/http_stream'
 
 describe "Yajl HTTP error" do
-  before(:all) do
+  before do
+    @uri = 'file://' + File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.error.dump")
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.error.dump"), 'r')
-    @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.error.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
-
+    allow(TCPSocket).to receive(:new).and_return(@request)
+    allow(@request).to receive(:write)
     begin
       Yajl::HttpStream.get(@uri)
     rescue Yajl::HttpStream::HttpError => e
@@ -23,10 +22,10 @@ describe "Yajl HTTP error" do
   end
 
   it "should contain the error code in the message" do
-    @error.message.should match(/404/)
+    expect(@error.message).to match(/404/)
   end
 
   it "should provide the HTTP response headers" do
-    @error.headers.keys.should include('ETag', 'Content-Length', 'Server')
+    expect(@error.headers.keys).to include('ETag', 'Content-Length', 'Server')
   end
-end
+end

data/spec/http/http_get_spec.rb

@@ -38,72 +38,72 @@ describe "Yajl HTTP GET request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.get(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.get(@uri)
+    expect(@template_hash).to eq(stream.get(@uri))
   end
 
   it "should parse a chunked response using instance method" do
     prepare_mock_request_dump :chunked
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
     stream.get(@uri) do |obj|
-      obj.should eql(@chunked_body)
+      expect(obj).to eql(@chunked_body)
     end
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.get(@uri)
+      expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.get(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.get(@uri)
+    expect(@template_hash).to eq(Yajl::HttpStream.get(@uri))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.get(@uri, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.get(@uri, :symbolize_keys => true))
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.get(@uri) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.get(@uri) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
 end

data/spec/http/http_post_spec.rb

@@ -40,84 +40,84 @@ describe "Yajl HTTP POST request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.post(@uri, @body)
+    expect(@template_hash).to eq(stream.post(@uri, @body))
   end
 
   it "should parse a raw response with hashed body" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.post(@uri, @hashed_body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @hashed_body))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+      expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.post(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @body))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.post(@uri, @body, :symbolize_keys => true))
   end
 
   it "should parse a chunked raw response" do
     prepare_mock_request_dump :chunked
     Yajl::HttpStream.post(@uri, @body) do |obj|
-      obj.should eql(@chunked_body)
+      expect(obj).to eql(@chunked_body)
     end
   end
 
   it "should throw Exception if chunked response and no block given" do
     prepare_mock_request_dump :chunked
-    lambda {Yajl::HttpStream.post(@uri, @body)}.should raise_error(Exception)
+    expect {Yajl::HttpStream.post(@uri, @body)}.to raise_error(Exception)
   end
 
   it "should throw InvalidContentType if unable to handle the MIME type" do
     prepare_mock_request_dump :html
-    lambda {Yajl::HttpStream.post(@uri, @body)}.should raise_error(Yajl::HttpStream::InvalidContentType)
+    expect {Yajl::HttpStream.post(@uri, @body)}.to raise_error(Yajl::HttpStream::InvalidContentType)
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.post(@uri, @body) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.post(@uri, @body) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
-end
+end

data/spec/http/http_put_spec.rb

@@ -39,67 +39,67 @@ describe "Yajl HTTP PUT request" do
   def prepare_mock_request_dump(format=:raw)
     @request = File.new(File.expand_path(File.dirname(__FILE__) + "/fixtures/http.#{format}.dump"), 'r')
     @uri = 'file://'+File.expand_path(File.dirname(__FILE__) + "/fixtures/http/http.#{format}.dump")
-    TCPSocket.should_receive(:new).and_return(@request)
-    @request.should_receive(:write)
+    expect(TCPSocket).to receive(:new).and_return(@request)
+    expect(@request).to receive(:write)
   end
 
   it "should parse a raw response" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
   end
 
   it "should parse a raw response using instance method" do
     prepare_mock_request_dump :raw
-    @uri.should_receive(:host)
-    @uri.should_receive(:port)
+    expect(@uri).to receive(:host)
+    expect(@uri).to receive(:port)
     stream = Yajl::HttpStream.new
-    @template_hash.should == stream.put(@uri, @body)
+    expect(@template_hash).to eq(stream.put(@uri, @body))
   end
 
   it "should parse a raw response with hashed body" do
     prepare_mock_request_dump :raw
-    @template_hash.should == Yajl::HttpStream.post(@uri, @hashed_body)
+    expect(@template_hash).to eq(Yajl::HttpStream.post(@uri, @hashed_body))
   end
 
   it "should parse a raw response and symbolize keys" do
     prepare_mock_request_dump :raw
-    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
   end
 
   if defined?(Yajl::Bzip2::StreamReader)
     it "should parse a bzip2 compressed response" do
       prepare_mock_request_dump :bzip2
-      @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+      expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
     end
 
     it "should parse a bzip2 compressed response and symbolize keys" do
       prepare_mock_request_dump :bzip2
-      @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+      expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
     end
   end
 
   it "should parse a deflate compressed response" do
     prepare_mock_request_dump :deflate
-    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
   end
 
   it "should parse a deflate compressed response and symbolize keys" do
     prepare_mock_request_dump :deflate
-    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
   end
 
   it "should parse a gzip compressed response" do
     prepare_mock_request_dump :gzip
-    @template_hash.should == Yajl::HttpStream.put(@uri, @body)
+    expect(@template_hash).to eq(Yajl::HttpStream.put(@uri, @body))
   end
 
   it "should parse a gzip compressed response and symbolize keys" do
     prepare_mock_request_dump :gzip
-    @template_hash_symbolized.should == Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true)
+    expect(@template_hash_symbolized).to eq(Yajl::HttpStream.put(@uri, @body, :symbolize_keys => true))
   end
 
   it "should raise when an HTTP code that isn't 200 is returned" do
     prepare_mock_request_dump :error
-    lambda { Yajl::HttpStream.put(@uri, @body) }.should raise_exception(Yajl::HttpStream::HttpError)
+    expect { Yajl::HttpStream.put(@uri, @body) }.to raise_exception(Yajl::HttpStream::HttpError)
   end
-end
+end