goliath 1.0.5 → 1.0.7

data/spec/integration/keepalive_spec.rb

@@ -10,13 +10,13 @@ describe 'HTTP Keep-Alive support' do
       r1.errback { fail }
       r1.callback do |c|
         b = MultiJson.load(c.response)
-        b['response'].should == 'test'
+        expect(b['response']).to eq('test')
 
         r2 = conn.get(:query => {:echo => 'test2'})
         r2.errback { fail }
         r2.callback do |c|
           b = MultiJson.load(c.response)
-          b['response'].should == 'test2'
+          expect(b['response']).to eq('test2')
 
           stop
         end

data/spec/integration/pipelining_spec.rb

@@ -24,15 +24,15 @@ describe 'HTTP Pipelining support' do
       r1.errback { fail }
       r1.callback do |c|
         res << c.response
-        c.response.should match('0.3')
+        expect(c.response).to match('0.3')
       end
 
       r2.errback { fail }
       r2.callback do |c|
         res << c.response
 
-        res.should == ['0.3', '0.2']
-        (Time.now.to_f - start).should be_within(0.1).of(0.3)
+        expect(res).to eq(['0.3', '0.2'])
+        expect(Time.now.to_f - start).to be_within(0.1).of(0.3)
 
         stop
       end

data/spec/integration/reloader_spec.rb

@@ -29,15 +29,15 @@ describe "Reloader" do
   end
 
   it 'adds reloader in dev mode' do
-    count(ReloaderDev).should == 1
+    expect(count(ReloaderDev)).to eq(1)
   end
 
   it "doesn't add if it's already there in dev mode" do
-    count(ReloaderAlreadyLoaded).should == 1
+    expect(count(ReloaderAlreadyLoaded)).to eq(1)
   end
 
   it "doesn't add in prod mode" do
     Goliath.env = :production
-    count(ReloaderProd).should == 0
+    expect(count(ReloaderProd)).to eq(0)
   end
 end

data/spec/integration/template_spec.rb

@@ -11,7 +11,7 @@ describe Template do
   it 'renders haml template with default haml layout' do
     with_api(Template, api_options) do
       get_request(:path => '/') do |c|
-        c.response.should =~ %r{<li><a href="/joke">Tell me a joke</a></li>}
+        expect(c.response).to match(%r{<li><a href="/joke">Tell me a joke</a></li>})
       end
     end
   end
@@ -19,7 +19,7 @@ describe Template do
   it 'renders haml template from string with default haml layout' do
     with_api(Template, api_options) do
       get_request(:path => '/haml_str') do |c|
-        c.response.should =~ %r{<h1>Header</h1>}
+        expect(c.response).to match(%r{<h1>Header</h1>})
       end
     end
   end
@@ -27,7 +27,7 @@ describe Template do
   it 'renders a markdown template with default haml layout' do
     with_api(Template, api_options) do
       get_request(:path => '/joke') do |c|
-        c.response.should =~ %r{<code>Arr, I dunno matey -- but it is driving me nuts!\s*</code>}m
+        expect(c.response).to match(%r{<code>Arr, I dunno matey -- but it is driving me nuts!\s*</code>}m)
       end
     end
   end
@@ -35,7 +35,7 @@ describe Template do
   it 'lets me specify an alternate layout engine' do
     with_api(Template, api_options) do
       get_request(:path => '/erb_me') do |c|
-        c.response.should =~ %r{I AM ERB</h1>}m
+        expect(c.response).to match(%r{I AM ERB</h1>}m)
       end
     end
   end
@@ -43,7 +43,7 @@ describe Template do
   it 'accepts local variables' do
     with_api(Template, api_options) do
       get_request(:path => '/erb_me') do |c|
-        c.response.should =~ %r{<title>HERE IS A JOKE</title>}m
+        expect(c.response).to match(%r{<title>HERE IS A JOKE</title>}m)
       end
     end
   end
@@ -52,8 +52,8 @@ describe Template do
     it 'raises an explanatory 500 error' do
       with_api(Template, api_options) do
         get_request(:path => '/oops') do |c|
-          c.response.should =~ %r{^\[:error, "Template no_such_template not found in .*examples/views for haml"\]$}
-          c.response_header.status.should == 500
+          expect(c.response).to match(%r{^\[:error, "Template no_such_template not found in .*examples/views for haml"\]$})
+          expect(c.response_header.status).to eq(500)
         end
       end
     end

data/spec/integration/test_helper_spec.rb

@@ -11,20 +11,20 @@ describe "with_api" do
     with_api(DummyServer, :log_file => "test.log") do |api|
       get_request({},err)
     end
-    File.exist?("test.log").should be_truthy
+    expect(File.exist?("test.log")).to be_truthy
     File.unlink("test.log")
   end
 
   it "should log on console if requested" do
     with_api(DummyServer, {:log_stdout => true }) do |api|
-      api.logger.outputters.select {|o| o.is_a? Log4r::StdoutOutputter}.should_not be_empty
+      expect(api.logger.outputters.select {|o| o.is_a? Log4r::StdoutOutputter}).not_to be_empty
       EM.stop
     end
   end
 
   it "should be verbose if asked" do
     with_api(DummyServer, {:verbose => true, :log_stdout => true }) do |api|
-      api.logger.level.should == Log4r::DEBUG
+      expect(api.logger.level).to eq(Log4r::DEBUG)
       EM.stop
     end
 

data/spec/integration/trace_spec.rb

@@ -8,7 +8,7 @@ describe Goliath::Rack::Tracer do
   it 'injects a trace param on a 200 (via async callback)' do
     with_api(Echo) do
       get_request({:query => {:echo => 'test'}}, err) do |c|
-        c.response_header['X_POSTRANK'].should =~ /trace\.start: [\d\.]+, total: [\d\.]+/
+        expect(c.response_header['X_POSTRANK']).to match(/trace\.start: [\d\.]+, total: [\d\.]+/)
       end
     end
   end
@@ -16,7 +16,7 @@ describe Goliath::Rack::Tracer do
   it 'injects a trace param on a 400 (direct callback)' do
     with_api(Echo) do
       get_request({}, err) do |c|
-        c.response_header['X_POSTRANK'].should =~ /trace\.start: [\d\.]+, total: [\d\.]+/
+        expect(c.response_header['X_POSTRANK']).to match(/trace\.start: [\d\.]+, total: [\d\.]+/)
       end
     end
   end

data/spec/integration/valid_spec.rb

@@ -38,7 +38,7 @@ describe ValidSingleParam do
   it 'returns OK with param' do
     with_api(ValidSingleParam) do
       get_request({:query => {:test => 'test'}}, err) do |c|
-        c.response.should == 'OK'
+        expect(c.response).to eq('OK')
       end
     end
   end
@@ -46,7 +46,7 @@ describe ValidSingleParam do
   it 'returns error without param' do
     with_api(ValidSingleParam) do
       get_request({}, err) do |c|
-        c.response.should == '[:error, "test identifier missing"]'
+        expect(c.response).to eq('[:error, "test identifier missing"]')
       end
     end
   end
@@ -64,9 +64,9 @@ describe ValidationErrorInEndpoint do
   it 'handles Goliath::Validation::Error correctly' do
     with_api(ValidationErrorInEndpoint) do
       get_request({}, err) do |c|
-        c.response.should == '[:error, "You Must Chill"]'
-        c.response_header.status.should == 420
-        c.response_header["Foo"].should == 'Bar'
+        expect(c.response).to eq('[:error, "You Must Chill"]')
+        expect(c.response_header.status).to eq(420)
+        expect(c.response_header["Foo"]).to eq('Bar')
       end
     end
   end
@@ -84,9 +84,9 @@ describe ValidationErrorWhileParsing do
   it 'handles Goliath::Validation::Error correctly' do
     with_api(ValidationErrorInEndpoint) do
       get_request({}, err) do |c|
-        c.response.should == '[:error, "You Must Chill"]'
-        c.response_header.status.should == 420
-        c.response_header["Foo"].should == 'Bar'
+        expect(c.response).to eq('[:error, "You Must Chill"]')
+        expect(c.response_header.status).to eq(420)
+        expect(c.response_header["Foo"]).to eq('Bar')
       end
     end
   end

data/spec/integration/websocket_spec.rb

@@ -26,7 +26,7 @@ describe "WebSocket" do
 
   it "should accept connection" do
     with_api(WebSocketEndPoint, {:verbose => true, :log_stdout => true}) do |server|
-      WebSocketEndPoint.any_instance.should_receive(:on_open)
+      expect_any_instance_of(WebSocketEndPoint).to receive(:on_open)
       ws_client_connect('/ws')
     end
   end
@@ -35,7 +35,7 @@ describe "WebSocket" do
     with_api(WebSocketEndPoint, {:verbose => true, :log_stdout => true}) do |server|
       ws_client_connect('/ws') do |client|
         client.send "hello"
-        client.receive.data.should == "hello"
+        expect(client.receive.data).to eq("hello")
       end
     end
   end

data/spec/spec_helper.rb

@@ -8,7 +8,5 @@ require 'goliath/test_helper'
 Goliath.env = :test
 
 RSpec.configure do |c|
-  c.include Goliath::TestHelper, :example_group => {
-    :file_path => /spec\/integration/
-  }
+  c.include Goliath::TestHelper, :file_path => /spec\/integration/
 end

data/spec/unit/api_spec.rb

@@ -7,7 +7,7 @@ describe Goliath::API do
 
   describe "middlewares" do
     it "doesn't change after multi calls" do
-      2.times { DummyApi.middlewares.size.should eq(2) }
+      2.times { expect(DummyApi.middlewares.size).to eq(2) }
     end
   end
 end

data/spec/unit/connection_spec.rb

@@ -9,39 +9,39 @@ describe Goliath::Connection do
     it 'accepts an app' do
       app = double('app')
       @c.app = app
-      @c.app.should == app
+      expect(@c.app).to eq(app)
     end
 
     it 'accepts a logger' do
       logger = double('logger')
       @c.logger = logger
-      @c.logger.should == logger
+      expect(@c.logger).to eq(logger)
     end
 
     it 'accepts a status object' do
       status = double('status')
       @c.status = status
-      @c.status.should == status
+      expect(@c.status).to eq(status)
     end
 
     it 'accepts config' do
       config = double('config')
       @c.config = config
-      @c.config.should == config
+      expect(@c.config).to eq(config)
     end
   end
 
   describe 'post_init' do
     it 'sets up the parser' do
       @c.post_init
-      @c.instance_variable_get("@parser").should_not be_nil
+      expect(@c.instance_variable_get("@parser")).not_to be_nil
     end
   end
 
   describe 'receive_data' do
     it 'passes data to the http parser' do
       request_mock = double("parser").as_null_object
-      request_mock.should_receive(:<<)
+      expect(request_mock).to receive(:<<)
 
       current_mock = double("current").as_null_object
 
@@ -52,10 +52,10 @@ describe Goliath::Connection do
 
     it "closes the connection when a parse error is received" do
       current_mock = double("current").as_null_object
-      current_mock.should_receive(:close)
+      expect(current_mock).to receive(:close)
 
       @c.instance_variable_set("@current", current_mock)
-      lambda { @c.receive_data("bad data") }.should_not raise_error
+      expect { @c.receive_data("bad data") }.not_to raise_error
     end
   end
 

data/spec/unit/console_spec.rb

@@ -9,9 +9,9 @@ describe Goliath::Console do
 
   describe 'run!' do
     it "starts a irb session" do
-      Object.should_receive(:send).with(:define_method, :goliath_server)
-      IRB.should_receive(:start)
-      @server.should_receive(:load_config)
+      expect(Object).to receive(:send).with(:define_method, :goliath_server)
+      expect(IRB).to receive(:start)
+      expect(@server).to receive(:load_config)
       Goliath::Console.run!(@server)
     end
   end

data/spec/unit/env_spec.rb

@@ -7,49 +7,49 @@ describe Goliath::Env do
   end
 
   it 'responds to []=' do
-    lambda { @env['test'] = 'blah' }.should_not raise_error
+    expect { @env['test'] = 'blah' }.not_to raise_error
   end
 
   it 'responds to []' do
     @env['test'] = 'blah'
-    lambda { @env['test'].should == 'blah' }.should_not raise_error
+    expect { expect(@env['test']).to eq('blah') }.not_to raise_error
   end
 
   context '#method_missing' do
     it 'allows access to items as methods' do
       @env['db'] = 'test'
-      @env.db.should == 'test'
+      expect(@env.db).to eq('test')
     end
 
     it 'allows access to config items as methods' do
       @env['config'] = {}
       @env['config']['db'] = 'test'
-      @env.db.should == 'test'
+      expect(@env.db).to eq('test')
     end
   end
 
   context '#respond_to?' do
     it 'returns true for items in the hash' do
       @env['test'] = 'true'
-      @env.respond_to?(:test).should be true
+      expect(@env.respond_to?(:test)).to be true
     end
 
     it 'returns false for items not in hash' do
-      @env.respond_to?(:test).should be false
+      expect(@env.respond_to?(:test)).to be false
     end
 
     it 'returns true for items in the config hash' do
       @env['config'] = {'test' => true}
-      @env.respond_to?(:test).should be true
+      expect(@env.respond_to?(:test)).to be true
     end
 
     it 'returns false for items not in the config hash' do
       @env['config'] = {}
-      @env.respond_to?(:test).should be false
+      expect(@env.respond_to?(:test)).to be false
     end
 
     it 'delegates if not found' do
-      @env.respond_to?(:[]).should be true
+      expect(@env.respond_to?(:[])).to be true
     end
   end
 end

data/spec/unit/headers_spec.rb

@@ -8,46 +8,46 @@ describe Goliath::Headers do
 
   it 'outputs in the correct format' do
     @h['my_header'] = 'my_value'
-    @h.to_s.should == "my_header: my_value\r\n"
+    expect(@h.to_s).to eq("my_header: my_value\r\n")
   end
 
   it 'suppresses duplicate keys' do
     @h['my_header'] = 'my_value1'
     @h['my_header'] = 'my_value2'
-    @h.to_s.should == "my_header: my_value1\r\n"
+    expect(@h.to_s).to eq("my_header: my_value1\r\n")
   end
 
   it 'returns true if a key has been set' do
     @h['my_header'] = 'my_value'
-    @h.has_key?('my_header').should be true
+    expect(@h.has_key?('my_header')).to be true
   end
 
   it 'returns false if the key has not been set' do
-    @h.has_key?('my_header').should be false
+    expect(@h.has_key?('my_header')).to be false
   end
 
   it 'ignores nil values' do
     @h['my_header'] = nil
-    @h.to_s.should == ''
+    expect(@h.to_s).to eq('')
   end
 
   it 'allows a value after setting nil' do
     @h['my_header'] = nil
     @h['my_header'] = 'my_value'
-    @h.to_s.should == "my_header: my_value\r\n"
+    expect(@h.to_s).to eq("my_header: my_value\r\n")
   end
 
   it 'formats time as an http time' do
     time = Time.now
     @h['my_time'] = time
-    @h.to_s.should == "my_time: #{time.httpdate}\r\n"
+    expect(@h.to_s).to eq("my_time: #{time.httpdate}\r\n")
   end
 
   %w(Set-Cookie Set-Cookie2 Warning WWW-Authenticate).each do |key|
     it "allows #{key} as to be duplicate" do
       @h[key] = 'value1'
       @h[key] = 'value2'
-      @h.to_s.should == "#{key}: value1\r\n#{key}: value2\r\n"
+      expect(@h.to_s).to eq("#{key}: value1\r\n#{key}: value2\r\n")
     end
   end
 end

data/spec/unit/rack/default_mime_type_spec.rb

@@ -14,21 +14,21 @@ describe Goliath::Rack::DefaultMimeType do
   context 'accept header cleanup' do
     it 'handles a nil header' do
       env['HTTP_ACCEPT'] = nil
-      lambda { dmt.call(env) }.should_not raise_error
+      expect { dmt.call(env) }.not_to raise_error
     end
 
     %w(gzip deflate compressed identity).each do |type|
       it "removes #{type} from the accept header" do
         env['HTTP_ACCEPT'] = "text/html, #{type}, text/javascript"
         dmt.call(env)
-        env['HTTP_ACCEPT'].should == 'text/html, text/javascript'
+        expect(env['HTTP_ACCEPT']).to eq('text/html, text/javascript')
       end
     end
 
     it 'sets to */* if all entries removed' do
       env['HTTP_ACCEPT'] = 'identity'
       dmt.call(env)
-      env['HTTP_ACCEPT'].should == '*/*'
+      expect(env['HTTP_ACCEPT']).to eq('*/*')
     end
   end
 end

data/spec/unit/rack/formatters/json_spec.rb

@@ -3,7 +3,7 @@ require 'goliath/rack/formatters/json'
 
 describe Goliath::Rack::Formatters::JSON do
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::JSON.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::JSON.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -13,41 +13,63 @@ describe Goliath::Rack::Formatters::JSON do
     end
 
     it 'checks content type for application/json' do
-      @js.json_response?({'Content-Type' => 'application/json'}).should be_truthy
+      expect(@js.json_response?({'Content-Type' => 'application/json'})).to be_truthy
+    end
+
+    it 'checks content type for application/vnd.api+json' do
+      expect(@js.json_response?({'Content-Type' => 'application/vnd.api+json'})).to be_truthy
+    end
+
+    it 'checks content type for application/javascript' do
+      expect(@js.json_response?({'Content-Type' => 'application/javascript'})).to be_truthy
     end
 
     it 'returns false for non-applicaton/json types' do
-      @js.json_response?({'Content-Type' => 'application/xml'}).should be_falsey
+      expect(@js.json_response?({'Content-Type' => 'application/xml'})).to be_falsey
     end
 
     it 'calls the app with the provided environment' do
       env_mock = double('env').as_null_object
-      @app.should_receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
+      expect(@app).to receive(:call).with(env_mock).and_return([200, {}, {"a" => 1}])
       @js.call(env_mock)
     end
 
     it 'formats the body into json if content-type is json' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
+    end
+
+    it 'formats the body into json if content-type is vnd.api+json' do
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/vnd.api+json'}, {:a => 1, :b => 2}])
+
+      status, header, body = @js.call({})
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
+    end
+
+    it 'formats the body into json if content-type is javascript' do
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/javascript'}, {:a => 1, :b => 2}])
 
       status, header, body = @js.call({})
-      lambda { MultiJson.load(body.first)['a'].should == 1 }.should_not raise_error
+      expect { expect(MultiJson.load(body.first)['a']).to eq(1) }.not_to raise_error
     end
 
     it "doesn't format to json if the type is not application/json" do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      MultiJson.should_not_receive(:dump)
+      expect(MultiJson).not_to receive(:dump)
       status, header, body = @js.call({})
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
-      MultiJson.should_not_receive(:dump)
+      expect(MultiJson).not_to receive(:dump)
       status, header, body = @js.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
     end
   end
 end

data/spec/unit/rack/formatters/plist_spec.rb

@@ -17,7 +17,7 @@ describe Goliath::Rack::Formatters::PLIST do
   end
 
   it 'accepts an app' do
-    lambda { Goliath::Rack::Formatters::PLIST.new('my app') }.should_not raise_error
+    expect { Goliath::Rack::Formatters::PLIST.new('my app') }.not_to raise_error
   end
 
   describe 'with a formatter' do
@@ -27,23 +27,23 @@ describe Goliath::Rack::Formatters::PLIST do
     end
 
     it 'formats the body into plist if content-type is plist' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/x-plist'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/x-plist'}, {:a => 1, :b => 2}])
 
       status, header, body = @m.call({})
-      body.should == ["plist: {:a=>1, :b=>2}"]
+      expect(body).to eq(["plist: {:a=>1, :b=>2}"])
     end
 
     it "doesn't format to plist if the type is not plist" do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
       status, header, body = @m.call({})
-      status.should == 200
-      header.should == {'Content-Type' => 'application/xml'}
+      expect(status).to eq(200)
+      expect(header).to eq({'Content-Type' => 'application/xml'})
 
-      body[:a].should == 1
+      expect(body[:a]).to eq(1)
     end
 
     it 'returns the status and headers' do
-      @app.should_receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
+      expect(@app).to receive(:call).and_return([200, {'Content-Type' => 'application/xml'}, {:a => 1, :b => 2}])
 
       status, header, body = @m.call({})
     end