yajl-ruby 1.2.3 → 1.3.0

data/spec/http/http_stream_options_spec.rb

@@ -8,20 +8,20 @@ describe "Passing options to HttpStream instance methods" do
   end
 
   it "should not create a new socket it one is provided" do
-    TCPSocket.should_not_receive(:new)
+    expect(TCPSocket).not_to receive(:new)
     options = {:socket => :my_provided_socket}
 
     @stream.send(:initialize_socket, URI.parse("http://google.com"), options)
 
-    options[:socket].should == :my_provided_socket
+    expect(options[:socket]).to eq(:my_provided_socket)
   end
 
   it "should create a new socket if one is not provided" do
-    TCPSocket.should_receive(:new).with("google.com", 80).and_return( :tcp_socket )
+    expect(TCPSocket).to receive(:new).with("google.com", 80).and_return( :tcp_socket )
     options = {}
 
     @stream.send(:initialize_socket, URI.parse("http://google.com"), options)
 
-    options[:socket].should == :tcp_socket
+    expect(options[:socket]).to eq(:tcp_socket)
   end
 end

data/spec/json_gem_compatibility/compatibility_spec.rb

@@ -7,109 +7,109 @@ describe "JSON Gem compatability API" do
   it "shoud not mixin #to_json on base objects until compatability has been enabled" do
     d = Dummy.new
 
-    d.respond_to?(:to_json).should_not be_true
-    "".respond_to?(:to_json).should_not be_true
-    1.respond_to?(:to_json).should_not be_true
-    "1.5".to_f.respond_to?(:to_json).should_not be_true
-    [].respond_to?(:to_json).should_not be_true
-    {:foo => "bar"}.respond_to?(:to_json).should_not be_true
-    true.respond_to?(:to_json).should_not be_true
-    false.respond_to?(:to_json).should_not be_true
-    nil.respond_to?(:to_json).should_not be_true
+    expect(d.respond_to?(:to_json)).not_to be_truthy
+    expect("".respond_to?(:to_json)).not_to be_truthy
+    expect(1.respond_to?(:to_json)).not_to be_truthy
+    expect("1.5".to_f.respond_to?(:to_json)).not_to be_truthy
+    expect([].respond_to?(:to_json)).not_to be_truthy
+    expect({:foo => "bar"}.respond_to?(:to_json)).not_to be_truthy
+    expect(true.respond_to?(:to_json)).not_to be_truthy
+    expect(false.respond_to?(:to_json)).not_to be_truthy
+    expect(nil.respond_to?(:to_json)).not_to be_truthy
   end
 
   it "should mixin #to_json on base objects after compatability has been enabled" do
     require 'yajl/json_gem'
     d = Dummy.new
 
-    d.respond_to?(:to_json).should be_true
-    "".respond_to?(:to_json).should be_true
-    1.respond_to?(:to_json).should be_true
-    "1.5".to_f.respond_to?(:to_json).should be_true
-    [].respond_to?(:to_json).should be_true
-    {:foo => "bar"}.respond_to?(:to_json).should be_true
-    true.respond_to?(:to_json).should be_true
-    false.respond_to?(:to_json).should be_true
-    nil.respond_to?(:to_json).should be_true
+    expect(d.respond_to?(:to_json)).to be_truthy
+    expect("".respond_to?(:to_json)).to be_truthy
+    expect(1.respond_to?(:to_json)).to be_truthy
+    expect("1.5".to_f.respond_to?(:to_json)).to be_truthy
+    expect([].respond_to?(:to_json)).to be_truthy
+    expect({:foo => "bar"}.respond_to?(:to_json)).to be_truthy
+    expect(true.respond_to?(:to_json)).to be_truthy
+    expect(false.respond_to?(:to_json)).to be_truthy
+    expect(nil.respond_to?(:to_json)).to be_truthy
   end
 
   it "should require yajl/json_gem to enable the compatability API" do
-    defined?(JSON).should be_true
+    expect(defined?(JSON)).to be_truthy
 
-    JSON.respond_to?(:parse).should be_true
-    JSON.respond_to?(:generate).should be_true
-    JSON.respond_to?(:pretty_generate).should be_true
-    JSON.respond_to?(:load).should be_true
-    JSON.respond_to?(:dump).should be_true
+    expect(JSON.respond_to?(:parse)).to be_truthy
+    expect(JSON.respond_to?(:generate)).to be_truthy
+    expect(JSON.respond_to?(:pretty_generate)).to be_truthy
+    expect(JSON.respond_to?(:load)).to be_truthy
+    expect(JSON.respond_to?(:dump)).to be_truthy
   end
 
   it "should allow default parsing options be set with JSON.default_options" do
     default = JSON.default_options[:symbolize_keys]
-    JSON.parse('{"foo": 1234}').should === {"foo" => 1234}
+    expect(JSON.parse('{"foo": 1234}')).to be === {"foo" => 1234}
     JSON.default_options[:symbolize_keys] = true
-    JSON.parse('{"foo": 1234}').should === {:foo => 1234}
+    expect(JSON.parse('{"foo": 1234}')).to be === {:foo => 1234}
     JSON.default_options[:symbolize_keys] = default # ensure the rest of the test cases expect the default
   end
 
   it "should also allow the json gem's symbolize_names key" do
-    JSON.parse('{"foo": 1234}', :symbolize_names => true).should === {:foo => 1234}
+    expect(JSON.parse('{"foo": 1234}', :symbolize_names => true)).to be === {:foo => 1234}
   end
 
   it "should encode arbitrary classes via their default to_json method" do
     d = Dummy.new
-    d.to_json.should == "\"#{d.to_s}\""
+    expect(d.to_json).to eq("\"#{d.to_s}\"")
 
     t = Time.now
-    t.to_json.should == "\"#{t.to_s}\""
+    expect(t.to_json).to eq("\"#{t.to_s}\"")
 
     da = Date.today
-    da.to_json.should == "\"#{da.to_s}\""
+    expect(da.to_json).to eq("\"#{da.to_s}\"")
 
     dt = DateTime.new
-    dt.to_json.should == "\"#{dt.to_s}\""
+    expect(dt.to_json).to eq("\"#{dt.to_s}\"")
   end
 
   it "should have the standard parsing and encoding exceptions mapped" do
-    JSON::JSONError.new.is_a?(StandardError).should be_true
-    JSON::ParserError.new.is_a?(JSON::JSONError).should be_true
-    JSON::GeneratorError.new.is_a?(JSON::JSONError).should be_true
+    expect(JSON::JSONError.new.is_a?(StandardError)).to be_truthy
+    expect(JSON::ParserError.new.is_a?(JSON::JSONError)).to be_truthy
+    expect(JSON::GeneratorError.new.is_a?(JSON::JSONError)).to be_truthy
 
-    lambda {
+    expect {
       JSON.parse("blah")
-    }.should raise_error(JSON::ParserError)
+    }.to raise_error(JSON::ParserError)
 
-    lambda {
+    expect {
       JSON.generate(0.0/0.0)
-    }.should raise_error(JSON::GeneratorError)
+    }.to raise_error(JSON::GeneratorError)
   end
 
   context "ported tests for Unicode" do
     it "should be able to encode and parse unicode" do
-      '""'.should eql(''.to_json)
-      '"\\b"'.should eql("\b".to_json)
-      '"\u0001"'.should eql(0x1.chr.to_json)
-      '"\u001F"'.should eql(0x1f.chr.to_json)
-      '" "'.should eql(' '.to_json)
-      "\"#{0x7f.chr}\"".should eql(0x7f.chr.to_json)
+      expect('""').to eql(''.to_json)
+      expect('"\\b"').to eql("\b".to_json)
+      expect('"\u0001"').to eql(0x1.chr.to_json)
+      expect('"\u001F"').to eql(0x1f.chr.to_json)
+      expect('" "').to eql(' '.to_json)
+      expect("\"#{0x7f.chr}\"").to eql(0x7f.chr.to_json)
       utf8 = [ "© ≠ €! \01" ]
       json = "[\"© ≠ €! \\u0001\"]"
-      json.should eql(utf8.to_json)
-      utf8.should eql(JSON.parse(json))
+      expect(json).to eql(utf8.to_json)
+      expect(utf8).to eql(JSON.parse(json))
       utf8 = ["\343\201\202\343\201\204\343\201\206\343\201\210\343\201\212"]
       json = "[\"あいうえお\"]"
-      json.should eql(utf8.to_json)
-      utf8.should eql(JSON.parse(json))
+      expect(json).to eql(utf8.to_json)
+      expect(utf8).to eql(JSON.parse(json))
       utf8 = ['საქართველო']
       json = "[\"საქართველო\"]"
-      json.should eql(utf8.to_json)
-      utf8.should eql(JSON.parse(json))
-      '["Ã"]'.should eql(JSON.generate(["Ã"]))
-      ["€"].should eql(JSON.parse('["\u20ac"]'))
+      expect(json).to eql(utf8.to_json)
+      expect(utf8).to eql(JSON.parse(json))
+      expect('["Ã"]').to eql(JSON.generate(["Ã"]))
+      expect(["€"]).to eql(JSON.parse('["\u20ac"]'))
       utf8_str = "\xf0\xa0\x80\x81"
       utf8 = [utf8_str]
       json = "[\"#{utf8_str}\"]"
-      json.should eql(JSON.generate(utf8))
-      utf8.should eql(JSON.parse(json))
+      expect(json).to eql(JSON.generate(utf8))
+      expect(utf8).to eql(JSON.parse(json))
     end
   end
 
@@ -144,25 +144,25 @@ describe "JSON Gem compatability API" do
 
     it "should be able to unparse" do
       json = JSON.generate(@hash)
-      JSON.parse(@json2).should == JSON.parse(json)
+      expect(JSON.parse(@json2)).to eq(JSON.parse(json))
       parsed_json = JSON.parse(json)
-      @hash.should == parsed_json
+      expect(@hash).to eq(parsed_json)
       json = JSON.generate({1=>2})
-      '{"1":2}'.should eql(json)
+      expect('{"1":2}').to eql(json)
       parsed_json = JSON.parse(json)
-      {"1"=>2}.should == parsed_json
+      expect({"1"=>2}).to eq(parsed_json)
     end
 
     it "should be able to unparse pretty" do
       json = JSON.pretty_generate(@hash)
-      JSON.parse(@json3).should == JSON.parse(json)
+      expect(JSON.parse(@json3)).to eq(JSON.parse(json))
       parsed_json = JSON.parse(json)
-      @hash.should == parsed_json
+      expect(@hash).to eq(parsed_json)
       json = JSON.pretty_generate({1=>2})
       test = "{\n  \"1\": 2\n}".chomp
-      test.should == json
+      expect(test).to eq(json)
       parsed_json = JSON.parse(json)
-      {"1"=>2}.should == parsed_json
+      expect({"1"=>2}).to eq(parsed_json)
     end
   end
 
@@ -174,33 +174,33 @@ describe "JSON Gem compatability API" do
 
     JSON_FAILED.each do |name, source|
       it "should not be able to parse #{File.basename(name)} as an IO" do
-          lambda {
+          expect {
             JSON.parse(StringIO.new(source))
-          }.should raise_error(JSON::ParserError)
+          }.to raise_error(JSON::ParserError)
       end
     end
 
     JSON_FAILED.each do |name, source|
       it "should not be able to parse #{File.basename(name)} as a string" do
-          lambda {
+          expect {
             JSON.parse(source)
-          }.should raise_error(JSON::ParserError)
+          }.to raise_error(JSON::ParserError)
       end
     end
 
     JSON_PASSED.each do |name, source|
       it "should be able to parse #{File.basename(name)} as an IO" do
-          lambda {
+          expect {
             JSON.parse(StringIO.new(source))
-          }.should_not raise_error
+          }.not_to raise_error
       end
     end
 
     JSON_PASSED.each do |name, source|
       it "should be able to parse #{File.basename(name)} as a string" do
-          lambda {
+          expect {
             JSON.parse(source)
-          }.should_not raise_error
+          }.not_to raise_error
       end
     end
   end

data/spec/parsing/active_support_spec.rb

@@ -36,29 +36,29 @@ describe "ActiveSupport test cases" do
 
   TESTS.each do |json, expected|
     it "should be able to parse #{json} as an IO" do
-      lambda {
-        Yajl::Parser.parse(StringIO.new(json)).should == expected
-      }.should_not raise_error
+      expect {
+        expect(Yajl::Parser.parse(StringIO.new(json))).to eq(expected)
+      }.not_to raise_error
     end
   end
 
   TESTS.each do |json, expected|
     it "should be able to parse #{json} as a string" do
-      lambda {
-        Yajl::Parser.parse(json).should == expected
-      }.should_not raise_error
+      expect {
+        expect(Yajl::Parser.parse(json)).to eq(expected)
+      }.not_to raise_error
     end
   end
 
   it "should fail parsing {: 1} as an IO" do
-    lambda {
+    expect {
       Yajl::Parser.parse(StringIO.new("{: 1}"))
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 
   it "should fail parsing {: 1} as a string" do
-    lambda {
+    expect {
       Yajl::Parser.parse("{: 1}")
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 end

data/spec/parsing/chunked_spec.rb

@@ -14,25 +14,25 @@ describe "Chunked parser" do
   end
 
   it "should parse a single chunk" do
-    @callback.should_receive(:call).with(@final)
+    expect(@callback).to receive(:call).with(@final)
     @parser << '[{"abc": 123},{"def": 456}]'
   end
 
   it "should parse a single chunk, 3 times" do
-    @callback.should_receive(:call).with(@final).exactly(3).times
+    expect(@callback).to receive(:call).with(@final).exactly(3).times
     @parser << '[{"abc": 123},{"def": 456}]'
     @parser << '[{"abc": 123},{"def": 456}]'
     @parser << '[{"abc": 123},{"def": 456}]'
   end
 
   it "should parse in two chunks" do
-    @callback.should_receive(:call).with(@final)
+    expect(@callback).to receive(:call).with(@final)
     @parser << '[{"abc": 123},'
     @parser << '{"def": 456}]'
   end
 
   it "should parse in 2 chunks, twice" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser << '[{"abc": 123},'
     @parser << '{"def": 456}]'
     @parser << '[{"abc": 123},'
@@ -40,57 +40,57 @@ describe "Chunked parser" do
   end
 
   it "should parse 2 JSON strings, in 3 chunks" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser << '[{"abc": 123},'
     @parser << '{"def": 456}][{"abc": 123},{"def":'
     @parser << ' 456}]'
   end
 
   it "should parse 2 JSON strings in 1 chunk" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser << '[{"abc": 123},{"def": 456}][{"abc": 123},{"def": 456}]'
   end
 
   it "should parse 2 JSON strings from an IO" do
-    @callback.should_receive(:call).with(@final).exactly(2).times
+    expect(@callback).to receive(:call).with(@final).exactly(2).times
     @parser.parse(StringIO.new('[{"abc": 123},{"def": 456}][{"abc": 123},{"def": 456}]'))
   end
 
   it "should parse a JSON string an IO and fire callback once" do
-    @callback.should_receive(:call).with(@final)
+    expect(@callback).to receive(:call).with(@final)
     @parser.parse(StringIO.new('[{"abc": 123},{"def": 456}]'))
   end
 
   it "should parse twitter_stream.json and fire callback 430 times" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
-    @callback.should_receive(:call).exactly(430).times
-    lambda {
+    expect(@callback).to receive(:call).exactly(430).times
+    expect {
       @parser.parse(json)
-    }.should_not raise_error
+    }.not_to raise_error
   end
 
   it "should parse twitter_stream.json and fire callback 430 times, with a block as the callback" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
-    @callback.should_receive(:call).exactly(0).times
+    expect(@callback).to receive(:call).exactly(0).times
     @parser.on_parse_complete = nil
-    lambda {
+    expect {
       times = 0
       @parser.parse(json) do |hsh|
         times += 1
       end
-      times.should eql(430)
-    }.should_not raise_error
+      expect(times).to eql(430)
+    }.not_to raise_error
   end
 
   it "should raise a Yajl::ParseError error if multiple JSON strings were found when no on_parse_complete callback assigned" do
     path = File.expand_path(File.dirname(__FILE__) + '/../../benchmark/subjects/twitter_stream.json')
     json = File.new(path, 'r')
     @parser.on_parse_complete = nil
-    @callback.should_receive(:call).exactly(0).times
-    lambda {
+    expect(@callback).to receive(:call).exactly(0).times
+    expect {
       @parser.parse(json)
-    }.should raise_error(Yajl::ParseError)
+    }.to raise_error(Yajl::ParseError)
   end
 end

data/spec/parsing/fixtures_spec.rb

@@ -8,33 +8,33 @@ describe "Parsing JSON Fixtures" do
 
   FAILED.each do |name, source|
     it "should not be able to parse #{File.basename(name)} as an IO" do
-        lambda {
+        expect {
           Yajl::Parser.parse(StringIO.new(source))
-        }.should raise_error(Yajl::ParseError)
+        }.to raise_error(Yajl::ParseError)
     end
   end
 
   FAILED.each do |name, source|
     it "should not be able to parse #{File.basename(name)} as a string" do
-        lambda {
+        expect {
           Yajl::Parser.parse(source)
-        }.should raise_error(Yajl::ParseError)
+        }.to raise_error(Yajl::ParseError)
     end
   end
 
   PASSED.each do |name, source|
     it "should be able to parse #{File.basename(name)} as an IO" do
-        lambda {
+        expect {
           Yajl::Parser.parse(StringIO.new(source))
-        }.should_not raise_error
+        }.not_to raise_error
     end
   end
 
   PASSED.each do |name, source|
     it "should be able to parse #{File.basename(name)} as a string" do
-        lambda {
+        expect {
           Yajl::Parser.parse(source)
-        }.should_not raise_error
+        }.not_to raise_error
     end
   end
 end

data/spec/parsing/large_number_spec.rb

@@ -40,7 +40,7 @@ describe 'Parsing very long text' do
 
     it 'runs successfully' do
       out, err, status = capture('ruby', script)
-      [err, status.exitstatus].should eq(['', 0])
+      expect([err, status.exitstatus]).to eq(['', 0])
     end
   end