goliath 1.0.4 → 1.0.6

data/spec/integration/event_stream_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require File.join(File.dirname(__FILE__), '../../', 'lib/goliath/test_helper_sse')
+require File.join(File.dirname(__FILE__), '../../', 'lib/goliath')
+require File.join(File.dirname(__FILE__), '../../', 'lib/goliath/api')
+
+class EventStreamEndpoint < Goliath::API
+  def self.events
+    @events ||= EM::Queue.new
+  end
+
+  def response(env)
+    self.class.events.pop do |event|
+      payload = if event.key?(:name)
+        "event: #{event[:name]}\ndata: #{event[:data]}\n\n"
+      else
+        "data: #{event[:data]}\n\n"
+      end
+      env.stream_send(payload)
+    end
+    streaming_response(200, 'Content-Type' => 'text/event-stream')
+  end
+end
+
+describe 'EventStream' do
+  include Goliath::TestHelper
+
+  context 'named events' do
+    it 'should accept stream' do
+      with_api(EventStreamEndpoint, {:verbose => true, :log_stdout => true}) do |server|
+        sse_client_connect('/stream') do |client|
+          client.listen_to('custom_event')
+          EventStreamEndpoint.events.push(name: 'custom_event', data: 'content')
+          expect(client.receive_on('custom_event')).to eq(['content'])
+          expect(client.receive).to eq([])
+        end
+      end
+    end
+  end
+
+  context 'unnamed events' do
+    it 'should accept stream' do
+      with_api(EventStreamEndpoint, {:verbose => true, :log_stdout => true}) do |server|
+        sse_client_connect('/stream') do |client|
+          EventStreamEndpoint.events.push(data: 'content')
+          expect(client.receive).to eq(['content'])
+        end
+      end
+    end
+  end
+end

data/spec/integration/exception_handling_spec.rb

@@ -0,0 +1,202 @@
+# This integration spec isn't *quite* about exception handling. It's more of a
+# regression test, since Goliath::Rack::Params used to swallow any exception
+# generated downstream from it in the middleware chain (even though
+# Goliath::API#call handles exceptions already).
+
+require 'spec_helper'
+
+class ExceptionHandlingMiddleware
+  include Goliath::Rack::AsyncMiddleware
+  include Goliath::Constants
+
+  def call(env)
+    # This kind of relies on downstream middleware raising their own exceptions
+    # if something goes wrong. Alternatively, they could rescue the exception
+    # and set env[RACK_EXCEPTION]. See #post_process.
+    super
+  rescue Exception => e
+    handle_exception(e)
+  end
+
+  def post_process(env, status, headers, body)
+    # If an exception was raised by Goliath::API#call, it will store the
+    # exception in env[RACK_EXCEPTION] and automatically generate an error
+    # response. We circumvent the usual error response by returning our own.
+    return handle_exception(env[RACK_EXCEPTION]) if env[RACK_EXCEPTION]
+    [status, headers, body]
+  end
+
+  private
+
+  def handle_exception(e)
+    # You could imagine this middleware having some sort of side effect, like
+    # sending your team an email alert detailing the exception. For the
+    # purposes of the spec, we'll just return some text.
+    [200, {}, "Exception raised: #{e.message}"]
+  end
+end
+
+class ExceptionRaisingMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    raise env.params['raise'] if env.params['raise']
+    @app.call(env)
+  end
+end
+
+class ExceptionHandlingAPI < Goliath::API
+  # The exception handling middleware should come first in the chain so that
+  # any exception in the rest of the chain gets rescued.
+  use ExceptionHandlingMiddleware
+
+  # Require param parsing before the exception raising middleware, because the
+  # latter depends on params being parsed. Herein lies the regression:
+  # Goliath::Rack::Params used to swallow any exceptions raised downstream from
+  # it (here, ExceptionRaisingMiddleware), so any upstream middleware (here,
+  # ExceptionHandlingMiddleware) would be none the wiser. Really, the only
+  # thing Goliath::Rack::Params should be worried about is whether it can parse
+  # the params.
+  use Goliath::Rack::Params
+
+  # Allow us to raise an exception on demand with the param raise=<message>.
+  # You could imagine something less dumb for a real-life application that
+  # incidentally raises an exception, if you'd like.
+  use ExceptionRaisingMiddleware
+
+  def response(env)
+    # Goliath::API#call ensures that any exceptions raised here get rescued and
+    # stored in env[RACK_EXCEPTION].
+    fail env.params['fail'] if env.params['fail']
+    [200, {}, 'No exceptions raised']
+  end
+end
+
+describe ExceptionHandlingAPI do
+  let(:err) { Proc.new { fail 'API request failed' } }
+
+  context 'when no exceptions get raised' do
+    let(:query) { '' }
+
+    it 'returns a normal response' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(200)
+          expect(c.response).to eq('No exceptions raised')
+        end
+      end
+    end
+  end
+
+  context 'when a middleware raises an exception' do
+    let(:query) { 'raise=zoinks' }
+
+    it 'handles the exception using ExceptionHandlingMiddleware' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(200)
+          expect(c.response).to eq('Exception raised: zoinks')
+        end
+      end
+    end
+  end
+
+  context 'when the API raises an exception' do
+    let(:query) { 'fail=jinkies' }
+
+    it 'handles the exception using ExceptionHandlingMiddleware' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(200)
+          expect(c.response).to eq('Exception raised: jinkies')
+        end
+      end
+    end
+  end
+
+  context 'when param parsing raises an exception' do
+    let(:query) { 'ambiguous[]=&ambiguous[4]=' }
+
+    it 'returns a validation error generated by Goliath::Rack::Params' do
+      with_api(ExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(400)
+          expect(c.response).to eq("[:error, \"Invalid parameters: Rack::Utils::ParameterTypeError\"]")
+        end
+      end
+    end
+  end
+end
+
+# This API has the same setup as ExceptionHandlingAPI, except for the crucial
+# difference that it does *not* use ExceptionHandlingMiddleware. This is to
+# make sure that exceptions are still rescued somewhere in an API call, even
+# though they aren't getting swallowed by Goliath::Rack::Params anymore.
+
+class PassiveExceptionHandlingAPI < Goliath::API
+  use Goliath::Rack::Params
+  use ExceptionRaisingMiddleware
+
+  def response(env)
+    fail env.params['fail'] if env.params['fail']
+    [200, {}, 'No exceptions raised']
+  end
+end
+
+describe PassiveExceptionHandlingAPI do
+  let(:err) { Proc.new { fail 'API request failed' } }
+
+  context 'when no exceptions get raised' do
+    let(:query) { '' }
+
+    it 'returns a normal response' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(200)
+          expect(c.response).to eq('No exceptions raised')
+        end
+      end
+    end
+  end
+
+  context 'when a middleware raises an exception' do
+    let(:query) { 'raise=ruh-roh' }
+
+    it 'returns the server error generated by Goliath::Request#process' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(500)
+          expect(c.response).to eq('ruh-roh')
+        end
+      end
+    end
+  end
+
+  context 'when the API raises an exception' do
+    let(:query) { 'fail=puppy-power' }
+
+    it 'returns the validation error generated by Goliath::API#call' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(500)
+          expect(c.response).to eq('[:error, "puppy-power"]')
+        end
+      end
+    end
+  end
+
+  context 'when param parsing raises an exception' do
+    let(:query) { 'ambiguous[]=&ambiguous[4]=' }
+
+    it 'returns a validation error generated by Goliath::Rack::Params' do
+      with_api(PassiveExceptionHandlingAPI) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header.status).to eq(400)
+          expect(c.response).to eq('[:error, "Invalid parameters: Rack::Utils::ParameterTypeError"]')
+        end
+      end
+    end
+  end
+end

data/spec/integration/http_log_spec.rb

@@ -42,7 +42,7 @@ describe HttpLog do
       mock_mongo(api)
 
       get_request({}, err) do |c|
-        c.response_header.status.should == 200
+        expect(c.response_header.status).to eq(200)
       end
     end
   end
@@ -53,9 +53,9 @@ describe HttpLog do
       mock_mongo(api)
 
       get_request({}, err) do |c|
-        c.response_header.status.should == 200
-        c.response_header['SPECIAL'].should == 'Header'
-        c.response.should == 'Hello from Responder'
+        expect(c.response_header.status).to eq(200)
+        expect(c.response_header['SPECIAL']).to eq('Header')
+        expect(c.response).to eq('Hello from Responder')
       end
     end
   end
@@ -63,8 +63,8 @@ describe HttpLog do
   context 'HTTP header handling' do
     it 'transforms back properly' do
       hl = HttpLog.new
-      hl.to_http_header("SPECIAL").should == 'Special'
-      hl.to_http_header("CONTENT_TYPE").should == 'Content-Type'
+      expect(hl.to_http_header("SPECIAL")).to eq('Special')
+      expect(hl.to_http_header("CONTENT_TYPE")).to eq('Content-Type')
     end
   end
 
@@ -75,8 +75,8 @@ describe HttpLog do
         mock_mongo(api)
 
         get_request({:query => {:first => :foo, :second => :bar, :third => :baz}}, err) do |c|
-          c.response_header.status.should == 200
-          c.response_header["PARAMS"].should == "first: foo|second: bar|third: baz"
+          expect(c.response_header.status).to eq(200)
+          expect(c.response_header["PARAMS"]).to eq("first: foo|second: bar|third: baz")
         end
       end
     end
@@ -89,8 +89,8 @@ describe HttpLog do
         mock_mongo(api)
 
         get_request({:path => '/my/request/path'}, err) do |c|
-          c.response_header.status.should == 200
-          c.response_header['PATH'].should == '/my/request/path'
+          expect(c.response_header.status).to eq(200)
+          expect(c.response_header['PATH']).to eq('/my/request/path')
         end
       end
     end
@@ -103,8 +103,8 @@ describe HttpLog do
         mock_mongo(api)
 
         get_request({:head => {:first => :foo, :second => :bar}}, err) do |c|
-          c.response_header.status.should == 200
-          c.response_header["HEADERS"].should =~ /First: foo\|Second: bar/
+          expect(c.response_header.status).to eq(200)
+          expect(c.response_header["HEADERS"]).to match(/First: foo\|Second: bar/)
         end
       end
     end
@@ -117,8 +117,8 @@ describe HttpLog do
         mock_mongo(api)
 
         get_request({}, err) do |c|
-          c.response_header.status.should == 200
-          c.response_header["METHOD"].should == "GET"
+          expect(c.response_header.status).to eq(200)
+          expect(c.response_header["METHOD"]).to eq("GET")
         end
       end
     end
@@ -129,8 +129,8 @@ describe HttpLog do
         mock_mongo(api)
 
         post_request({}, err) do |c|
-          c.response_header.status.should == 200
-          c.response_header["METHOD"].should == "POST"
+          expect(c.response_header.status).to eq(200)
+          expect(c.response_header["METHOD"]).to eq("POST")
         end
       end
     end

data/spec/integration/jsonp_spec.rb

@@ -6,26 +6,77 @@ class JSON_API < Goliath::API
   use Goliath::Rack::Render, 'json'
 
   def response(env)
-    [200, {'CONTENT_TYPE' => 'application/json'}, "OK"]
+    headers = {
+      'CONTENT_TYPE' => 'application/json',
+      # Note: specifically not 'CONTENT_LENGTH'. 'Content-Length' gets set by
+      # AsyncRack::ContentLength if not already present. So if we set
+      # 'CONTENT_LENGTH', no problem - AsyncRack recalculates the body's
+      # content length anyway and stores it in the 'Content-Length' header. But
+      # if we set 'Content-Length', AsyncRack will avoid overwriting it. We
+      # thus want the JSONP middleware to react to the case where we've
+      # *already* set the 'Content-Length' header before hitting it.
+      'Content-Length' => '2',
+    }
+    [200, headers, 'OK']
   end
 end
 
 describe 'JSONP' do
   let(:err) { Proc.new { fail "API request failed" } }
 
-  it 'sets the content type' do
-    with_api(JSON_API) do
-      get_request({:query => {:callback => 'test'}}, err) do |c|
-        c.response_header['CONTENT_TYPE'].should =~ %r{^application/javascript}
+  context 'without a callback param' do
+    let(:query) { {} }
+
+    it 'does not alter the content type' do
+      with_api(JSON_API) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header['CONTENT_TYPE']).to match(%r{^application/json})
+        end
+      end
+    end
+
+    it 'does not alter the content length' do
+      with_api(JSON_API) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header['CONTENT_LENGTH'].to_i).to eq(2)
+        end
+      end
+    end
+
+    it 'does not wrap the response with anything' do
+      with_api(JSON_API) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response).to eq('OK')
+        end
       end
     end
   end
 
-  it 'wraps response with callback' do
-    with_api(JSON_API) do
-      get_request({:query => {:callback => 'test'}}, err) do |c|
-        c.response.should =~ /^test\(.*\)$/
+  context 'with a callback param' do
+    let(:query) { { callback: 'test' } }
+
+    it 'adjusts the content type' do
+      with_api(JSON_API) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header['CONTENT_TYPE']).to match(%r{^application/javascript})
+        end
+      end
+    end
+
+    it 'adjusts the content length' do
+      with_api(JSON_API) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response_header['CONTENT_LENGTH'].to_i).to eq(8)
+        end
+      end
+    end
+
+    it 'wraps response with callback' do
+      with_api(JSON_API) do
+        get_request({ query: query }, err) do |c|
+          expect(c.response).to match(/^test\(.*\)$/)
+        end
       end
     end
   end
-end
+end

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_true
+    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
@@ -54,7 +54,7 @@ end
 
 class ValidationErrorInEndpoint < Goliath::API
   def response(env)
-    raise Goliath::Validation::Error.new(420, 'You Must Chill')
+    raise Goliath::Validation::Error.new(420, 'You Must Chill', {'Foo' => 'Bar'})
   end
 end
 
@@ -64,10 +64,30 @@ 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
+        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
 end
 
+class ValidationErrorWhileParsing < Goliath::API
+  def on_headers(env, headers)
+    raise Goliath::Validation::Error.new(420, 'You Must Chill', {'Foo' => 'Bar'})
+  end
+end
+
+describe ValidationErrorWhileParsing do
+  let(:err) { Proc.new { fail "API request failed" } }
+
+  it 'handles Goliath::Validation::Error correctly' do
+    with_api(ValidationErrorInEndpoint) do
+      get_request({}, err) do |c|
+        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
+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