regal 0.1.0 → 0.2.0

data/spec/regal/app_spec.rb

@@ -47,6 +47,8 @@ module Regal
       it 'responds with 404 when the path does not match any route' do
         get '/hello/fnord'
         expect(last_response.status).to eq(404)
+        get '/foo/bar/baz/qux'
+        expect(last_response.status).to eq(404)
       end
 
       it 'responds with 405 when the path matches a route but there is no handler for the HTTP method' do
@@ -129,10 +131,31 @@ module Regal
     end
 
     context 'an app doing work before route handlers' do
-      let :app do
-        App.new do
+      MountedBeforeApp = App.create do
+        before do |request|
+          request.attributes[:some_key] << 2
+        end
+
+        route 'in-mounted-app' do
           before do |request|
+            request.attributes[:some_key] << 3
+          end
+
+          get do |request|
+            request.attributes[:some_key].join(',')
+          end
+        end
+      end
+
+      let :state do
+        {}
+      end
+
+      let :app do
+        App.new(state: state) do
+          before do |request, _|
             request.attributes[:some_key] = [1]
+            request.attributes[:state][:before] = :called
           end
 
           get do |request|
@@ -185,7 +208,8 @@ module Regal
               response.body = 'whoopiedoo'
             end
 
-            get do
+            get do |_, response|
+              response.headers['X-HandlerCalled'] = 'yes'
               "I'm not called!"
             end
 
@@ -193,6 +217,8 @@ module Regal
               response.headers['WasAfterCalled'] = 'yes'
             end
           end
+
+          mount MountedBeforeApp
         end
       end
 
@@ -221,6 +247,14 @@ module Regal
         expect(last_response.status).to eq(307)
       end
 
+      context 'when the path does not match any route' do
+        it 'does not run any before blocks' do
+          get '/does-not-exist'
+          expect(last_response.status).to eq(404)
+          expect(state).to be_empty
+        end
+      end
+
       context 'when the response is marked as finished' do
         before do
           get '/redirect-before'
@@ -228,20 +262,49 @@ module Regal
 
         it 'does not call further handlers or before blocks when the response is marked as finished' do
           expect(last_response.body).to eq('Go somewhere else')
+          expect(last_response.headers).to_not have_key('X-HandlerCalled')
         end
 
         it 'calls after blocks' do
           expect(last_response.headers).to include('WasAfterCalled' => 'yes')
         end
       end
+
+      context 'with a mounted app' do
+        it 'runs the before blocks from both the mounting and the mounted app' do
+          get '/in-mounted-app'
+          expect(last_response.body).to eq('1,2,3')
+        end
+      end
     end
 
     context 'an app doing work after route handlers' do
-      let :app do
-        App.new do
+      MountedAfterApp = App.create do
+        after do |_, response|
+          response.body['list'] << 1
+        end
+
+        route 'in-mounted-app' do
           after do |_, response|
+            response.body['list'] << 2
+          end
+
+          get do
+            {'list' => []}
+          end
+        end
+      end
+
+      let :state do
+        {}
+      end
+
+      let :app do
+        App.new(state: state) do
+          after do |request, response|
             response.headers['Content-Type'] = 'application/json'
-            response.body = JSON.dump(response.body)
+            response.body = response.body.is_a?(String) ? %("#{response.body}") : JSON.dump(response.body)
+            request.attributes[:state][:after] = :called
           end
 
           get do |request|
@@ -260,11 +323,11 @@ module Regal
 
           route 'two-after' do
             after do |request, response|
-              response.body['list'] << 1
+              response.body['list'] << 2
             end
 
             after do |request, response|
-              response.body['list'] << 2
+              response.body['list'] << 1
             end
 
             get do |request|
@@ -281,6 +344,74 @@ module Regal
               end
             end
           end
+
+          route 'stops-early' do
+            before do |_, response|
+              response.body = 'before1'
+              response.finish
+            end
+
+            after do |_, response|
+              response.body << '|after1'
+            end
+
+            route 'not-called' do
+              before do |_, response|
+                response.body << '|before2'
+              end
+
+              after do |_, response|
+                response.body << '|after2'
+              end
+
+              get do |_, response|
+                response.body << '|handler'
+              end
+            end
+          end
+
+          route 'raises' do
+            before do |_, response|
+              response.body = 'before1'
+            end
+
+            after do |_, response|
+              response.body << '|after1'
+            end
+
+            rescue_from RuntimeError do
+            end
+
+            route 'not-called' do
+              before do |_, response|
+                response.body << '|before2'
+              end
+
+              after do |_, response|
+                response.body << '|after2'
+              end
+
+              get do |_, response|
+                response.body << '|handler'
+              end
+            end
+
+            route 'raises' do
+              before do |_, response|
+                response.body << '|before2'
+                raise 'Burk!'
+              end
+
+              after do |_, response|
+                response.body << '|after2'
+              end
+
+              get do
+              end
+            end
+          end
+
+          mount MountedAfterApp
         end
       end
 
@@ -303,6 +434,112 @@ module Regal
         get '/two-after/another-after'
         expect(last_response.body).to eq('{"list":[3,2,1]}')
       end
+
+      context 'when the path does not match any route' do
+        it 'does not run any before blocks' do
+          get '/does-not-exist'
+          expect(last_response.status).to eq(404)
+          expect(state).to be_empty
+        end
+      end
+
+      context 'with a mounted app' do
+        it 'runs the after blocks from both the mounting and the mounted app' do
+          get '/in-mounted-app'
+          expect(last_response.body).to eq('{"list":[2,1]}')
+        end
+      end
+
+      context 'when the request is finished by a before block' do
+        it 'runs only the after blocks from the same level and up' do
+          get '/stops-early/not-called'
+          expect(last_response.body).to eq('"before1|after1"')
+        end
+      end
+
+      context 'when a before block raises an error and it is handled by a rescue block' do
+        it 'runs only the after blocks from the same level as the rescue block, and up' do
+          get '/raises/raises'
+          expect(last_response.body).to eq('"before1|before2|after1"')
+        end
+      end
+
+      context 'when rescue block raises an error that is handled a few levels up' do
+        let :app do
+          App.new do
+            after do |_, response|
+              response.body = response.body.join('|')
+            end
+
+            route 'one' do
+              after do |_, response|
+                response.body << 'after1'
+              end
+
+              route 'two' do
+                after do |_, response|
+                  response.body << 'after2'
+                end
+
+                rescue_from StandardError do
+                end
+
+                route 'three' do
+                  after do |_, response|
+                    response.body << 'after3'
+                  end
+
+                  route 'four' do
+                    after do |_, response|
+                      response.body << 'after4'
+                    end
+
+                    rescue_from StandardError do
+                      raise 'Snork'
+                    end
+
+                    route 'raise-in-after' do
+                      after do |_, response|
+                        raise 'Bork'
+                      end
+
+                      get do
+                        []
+                      end
+                    end
+
+                    route 'raise-in-before' do
+                      before do |_, response|
+                        response.body = []
+                        raise 'Bork'
+                      end
+
+                      get do
+                      end
+                    end
+
+                    route 'raise-in-handler' do
+                      get do |_, response|
+                        response.body = []
+                        raise 'Bork'
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        it 'runs only the after blocks from the same level as the rescue block, and up' do
+          get '/one/two/three/four/raise-in-after'
+          expect(last_response.body).to eq('after2|after1')
+          get '/one/two/three/four/raise-in-before'
+          expect(last_response.body).to eq('after2|after1')
+          get '/one/two/three/four/raise-in-handler'
+          expect(last_response.body).to eq('after2|after1')
+        end
+      end
     end
 
     context 'an app that has capturing routes' do
@@ -378,6 +615,18 @@ module Regal
         end
       end
 
+      SimpleApp1 = App.create do
+        get do
+          'simple1'
+        end
+      end
+
+      SimpleApp2 = App.create do
+        get do
+          'simple2'
+        end
+      end
+
       let :app do
         App.new do
           route 'i' do
@@ -388,8 +637,26 @@ module Regal
           end
 
           route 'oh' do
+            get do
+              'oh'
+            end
+
             mount HelloApp
           end
+
+          route 'shadows' do
+            get do
+              'simple0'
+            end
+
+            mount SimpleApp1
+            mount SimpleApp2
+
+            route 'sub' do
+              mount SimpleApp1
+              mount SimpleApp2
+            end
+          end
         end
       end
 
@@ -416,42 +683,162 @@ module Regal
         expect(last_response.status).to eq(200)
         expect(last_response.body).to eq('hello')
       end
+
+      context 'when the mounting and the mounted apps have handlers that match a request' do
+        it 'calls the mounting app\'s handler' do
+          get '/shadows'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('simple0')
+        end
+      end
+
+      context 'when the mounted apps have handlers that match a request' do
+        it 'calls the last mounted app\'s handler', pending: true do
+          get '/shadows/sub'
+          expect(last_response.status).to eq(200)
+          expect(last_response.body).to eq('simple2')
+        end
+      end
+    end
+
+    context 'an app that groups routes together in scopes' do
+      let :app do
+        App.new do
+          route 'scoped' do
+            before do |_, response|
+              response.headers['CommonBefore'] = 'yes'
+            end
+
+            after do |_, response|
+              response.headers['CommonAfter'] = 'yes'
+            end
+
+            scope do
+              before do |_, response|
+                response.headers['BeforeScope'] = '1'
+              end
+
+              after do |_, response|
+                response.headers['AfterScope'] = '1'
+              end
+
+              get do
+                'scope1-level1'
+              end
+
+              route '1' do
+                get do
+                  'scope1-level2'
+                end
+              end
+            end
+
+            scope do
+              before do |_, response|
+                response.headers['BeforeScope'] = '2'
+              end
+
+              after do |_, response|
+                response.headers['AfterScope'] = '2'
+              end
+
+              get do
+                'scope2-level1'
+              end
+
+              scope do
+                before do |_, response|
+                  response.headers['BeforeSubScope'] = '2'
+                end
+
+                route '2' do
+                  get do
+                    'scope2-level2'
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      it 'routes a request' do
+        get '/scoped/1'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('scope1-level2')
+        get '/scoped/2'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('scope2-level2')
+      end
+
+      it 'picks the handler from the last scope when there are multiple candidates', pending: true do
+        get '/scoped'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to eq('scope2-level1')
+      end
+
+      it 'calls the route\'s parent scope\'s before blocks only' do
+        get '/scoped/1'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to include('BeforeScope' => '1')
+        get '/scoped/2'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to include('BeforeScope' => '2', 'BeforeSubScope' => '2')
+      end
+
+      it 'calls the route\'s parent scope\'s after blocks only' do
+        get '/scoped/1'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to include('AfterScope' => '1')
+        get '/scoped/2'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to include('AfterScope' => '2')
+      end
+
+      it 'calls the common before and after blocks' do
+        get '/scoped/1'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to include('CommonBefore' => 'yes', 'CommonAfter' => 'yes')
+        get '/scoped/2'
+        expect(last_response.status).to eq(200)
+        expect(last_response.headers).to include('CommonBefore' => 'yes', 'CommonAfter' => 'yes')
+      end
     end
 
     context 'an app that supports all HTTP methods' do
       let :app do
         App.new do
           get do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           head do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           options do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           delete do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           post do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           put do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           patch do |request|
-            request.request_method
+            request.env['REQUEST_METHOD']
           end
 
           route 'anything' do
             any do |request|
-              request.request_method
+              request.env['REQUEST_METHOD']
             end
           end
         end
@@ -522,6 +909,10 @@ module Regal
             'top_level_helper'
           end
 
+          rescue_from StandardError do |_, _, response|
+            response.body = top_level_helper
+          end
+
           route 'one' do
             def first_level_helper
               'first_level_helper'
@@ -549,6 +940,12 @@ module Regal
               end
             end
           end
+
+          route 'boom' do
+            get do
+              raise 'Bork'
+            end
+          end
         end
       end
 
@@ -575,164 +972,80 @@ module Regal
         expect(last_response.status).to eq(200)
         expect(last_response.body).to include('after:top_level_helper,first_level_helper,second_level_helper')
       end
+
+      it 'can use the helper methods in rescue blocks' do
+        get '/boom'
+        expect(last_response.status).to eq(200)
+        expect(last_response.body).to include('top_level_helper')
+      end
     end
 
     context 'an app that receives configuration when created' do
       let :app do
-        App.new(this_thing, that_other_thing) do
-          setup do |*args|
-            @args = args
+        App.new(fuzzinator: fuzzinator, blip_count: 3, counter: 0, str: '') do
+          route 'blip' do
+            get do |request|
+              "blip\n" * request.attributes[:blip_count]
+            end
           end
 
-          get do
-            @args.join(',')
+          route 'fuzz' do
+            get do |request|
+              request.attributes[:fuzzinator].fuzz(request.parameters['s'])
+            end
           end
 
-          route 'one' do
-            setup do |thing1, thing2|
-              @thing1 = thing1
-              @thing2 = thing2
+          route 'increment' do
+            before do |request|
+              request.attributes[:counter] += 1
             end
 
-            get do
-              [*@args, @thing1, @thing2].join(',')
+            get do |request|
+              request.attributes[:counter].to_s
             end
           end
 
-          route 'two' do
-            setup do |thing1, thing2|
-              @thing1 = thing1
-              @thing2 = thing2
-            end
-
-            setup do |_, thing_two|
-              @thing_two = thing_two
+          route 'append' do
+            before do |request|
+              request.attributes[:str] << '1'
             end
 
-            get do
-              [*@args, @thing1, @thing2, @thing_two].join(',')
+            get do |request|
+              request.attributes[:str].to_s
             end
           end
         end
       end
 
-      let :this_thing do
-        double(:this_thing, to_s: 'this_thing')
+      let :fuzzinator do
+        double(:fuzzinator)
       end
 
-      let :that_other_thing do
-        double(:that_other_thing, to_s: 'that_other_thing')
+      before do
+        allow(fuzzinator).to receive(:fuzz) { |s| s.split('').join('z') }
       end
 
-      it 'calls its setup methods with the configuration' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('this_thing,that_other_thing')
-      end
-
-      it 'calls the setup methods of all routes' do
-        get '/one'
+      it 'can access the hash given to .new through the request attributes hash' do
+        get '/blip'
         expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('this_thing,that_other_thing,this_thing,that_other_thing')
-      end
-
-      it 'calls all setup methods' do
-        get '/two'
+        expect(last_response.body).to eq("blip\nblip\nblip\n")
+        get '/fuzz?s=badaboom'
         expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('this_thing,that_other_thing,this_thing,that_other_thing,that_other_thing')
-      end
-    end
-
-    context 'an app that uses Rack middleware' do
-      class Reverser
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          response = @app.call(env)
-          body = response[2][0]
-          body && body.reverse!
-          response
-        end
-      end
-
-      class Uppercaser
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          response = @app.call(env)
-          body = response[2][0]
-          body && body.upcase!
-          response
-        end
-      end
-
-      class Mutator
-        def initialize(app, &block)
-          @app = app
-          @block = block
-        end
-
-        def call(env)
-          @app.call(@block.call(env))
-        end
+        expect(last_response.body).to eq('bzazdzazbzozozm')
       end
 
-      let :app do
-        App.new do
-          use Reverser
-
-          get do
-            'lorem ipsum'
-          end
-
-          route 'more' do
-            use Uppercaser
-
-            get do
-              'dolor sit'
-            end
-          end
-
-          route 'hello' do
-            use Rack::Runtime, 'Regal'
-            use Mutator do |env|
-              env['app.greeting'] = 'Bonjour'
-              env
-            end
-
-            get do |request|
-              request.env['app.greeting'] + ', ' + request.parameters['name']
-            end
-          end
-        end
-      end
-
-      it 'calls the middleware when processing the request' do
-        get '/'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('muspi merol')
-      end
-
-      it 'calls the middleware of all routes' do
-        get '/more'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('TIS ROLOD')
-      end
-
-      it 'passes arguments when instantiating the middleware' do
-        get '/hello?name=Eve'
-        expect(last_response.status).to eq(200)
-        expect(last_response.headers).to have_key('X-Runtime-Regal')
+      it 'gives each request its own copy of the attributes' do
+        get '/increment'
+        get '/increment'
+        get '/increment'
+        expect(last_response.body).to eq('1')
       end
 
-      it 'passes blocks when instantiating the middleware' do
-        get '/hello?name=Eve'
-        expect(last_response.status).to eq(200)
-        expect(last_response.body).to eq('Bonjour, Eve'.reverse)
+      it 'does not make a deep copy of the attributes' do
+        get '/append'
+        get '/append'
+        get '/append'
+        expect(last_response.body).to eq('111')
       end
     end
 
@@ -761,6 +1074,11 @@ module Regal
               'I will not be used'
             end
           end
+
+          route 'nil-body' do
+            get do
+            end
+          end
         end
       end
 
@@ -778,6 +1096,11 @@ module Regal
         get '/no-body'
         expect(last_response.body).to be_empty
       end
+
+      it 'assumes that a nil body is no body' do
+        get '/nil-body'
+        expect(last_response.body).to be_empty
+      end
     end
 
     context 'an app that responds with no-body response codes' do
@@ -791,6 +1114,17 @@ module Regal
               end
             end
           end
+
+          route 'with-after' do
+            get do |_, response|
+              response.status = 204
+              'this will not be returned'
+            end
+
+            after do |_, response|
+              response.body = 'this will not be returned either'
+            end
+          end
         end
       end
 
@@ -801,6 +1135,12 @@ module Regal
           expect(last_response.body).to be_empty
         end
       end
+
+      it 'ignores response bodies set by after blocks' do
+        get '/with-after'
+        expect(last_response.status).to eq(204)
+        expect(last_response.body).to be_empty
+      end
     end
 
     context 'an app that raises exceptions' do
@@ -808,6 +1148,45 @@ module Regal
       class AppError < StandardError; end
       class SpecificError < AppError; end
 
+      MountedRescuingApp = App.create do
+        rescue_from SpecificError do |_, _, response|
+          response.body = 'handled SpecificError in the mounted app'
+        end
+
+        route 'raise-specific-error' do
+          get do
+            raise SpecificError, 'Blam!'
+          end
+        end
+
+        route 'raise-app-error' do
+          get do
+            raise AppError, 'Kaboom!'
+          end
+        end
+
+        route 'raise-and-and-handle-app-error' do
+          rescue_from AppError do |_, _, response|
+            response.body = 'handled AppError in the mounted app'
+          end
+
+          get do
+            raise AppError, 'Kaboom!'
+          end
+        end
+      end
+
+      MountedNonRescuingApp = App.create do
+        after do
+          raise AppError, 'Kaboom!'
+        end
+
+        route 'raise-from-after' do
+          get do
+          end
+        end
+      end
+
       let :app do
         App.new do
           route 'unhandled' do
@@ -851,15 +1230,25 @@ module Regal
             end
 
             route 'from-after' do
+              after do |_, response|
+                response.headers['NextAfterWasCalled'] = 'yes'
+              end
+
               after do
                 raise SpecificError, 'Kazam!'
               end
 
-              after do |_, response|
-                response.headers['NextAfterWasCalled'] = 'yes'
+              get do
+              end
+            end
+
+            route 'from-rescue' do
+              rescue_from SpecificError do |e|
+                raise AppError, 'Badaboom!'
               end
 
               get do
+                raise SpecificError, 'Kaboom!'
               end
             end
 
@@ -871,6 +1260,40 @@ module Regal
                 raise SpecificError, 'Bam!'
               end
             end
+
+            route 'at-the-right-level' do
+              rescue_from SpecificError do |_, _, response|
+                response.headers['HandledAtLevel'] = '2'
+              end
+
+              route 'level-3' do
+                before do
+                  raise SpecificError, 'Badam!'
+                end
+
+                rescue_from SpecificError do |_, _, response|
+                  response.headers['HandledAtLevel'] = '3'
+                end
+
+                route 'level-4' do
+                  rescue_from SpecificError do |_, _, response|
+                    response.headers['HandledAtLevel'] = '4'
+                  end
+
+                  get do
+                  end
+                end
+              end
+            end
+          end
+
+          route 'with-mounted-app' do
+            rescue_from AppError do |_, _, response|
+              response.body = 'handled AppError in the mounting app'
+            end
+
+            mount MountedRescuingApp
+            mount MountedNonRescuingApp
           end
         end
       end
@@ -901,10 +1324,16 @@ module Regal
           expect(last_response.body).to eq('Bang!')
         end
 
+        it 'delegates them to matching error handlers at the same level, not below' do
+          get '/handled/at-the-right-level/level-3/level-4'
+          expect(last_response.headers).to include('HandledAtLevel' => '3')
+        end
+
         it 'calls after blocks when errors are handled' do
           get '/handled/from-before'
           expect(last_response.headers['WasAfterCalled']).to eq('yes')
         end
+
       end
 
       context 'from after blocks' do
@@ -919,6 +1348,37 @@ module Regal
           expect(last_response.headers['WasAfterCalled']).to eq('yes')
         end
       end
+
+      context 'from rescue blocks' do
+        it 'delegates them to the next matching error handler' do
+          get '/handled/from-rescue'
+          expect(last_response.body).to eq('Badaboom!')
+        end
+      end
+
+      context 'from mounted apps' do
+        it 'delegates them to matching error handlers in the mounting app' do
+          get '/with-mounted-app/raise-app-error'
+          expect(last_response.body).to eq('handled AppError in the mounting app')
+        end
+
+        it 'delegates them to matching error handlers declared at the top of the mounted app' do
+          get '/with-mounted-app/raise-specific-error'
+          expect(last_response.body).to eq('handled SpecificError in the mounted app')
+        end
+
+        it 'delegates them to matching error handlers declared in routes of the mounted app' do
+          get '/with-mounted-app/raise-and-and-handle-app-error'
+          expect(last_response.body).to eq('handled AppError in the mounted app')
+        end
+
+        context 'in after blocks' do
+          it 'delegates them to a matching error handler' do
+            get '/with-mounted-app/raise-from-after'
+            expect(last_response.body).to eq('handled AppError in the mounting app')
+          end
+        end
+      end
     end
   end
 end