hanami 2.0.0.beta4 → 2.0.0.rc1

data/spec/integration/rack_app/middleware_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack/test"
+require "stringio"
 
 RSpec.describe "Hanami web app", :app_integration do
   include Rack::Test::Methods
@@ -50,7 +51,7 @@ RSpec.describe "Hanami web app", :app_integration do
 
       module TestApp
         class App < Hanami::App
-          config.logger.stream = File.new("/dev/null", "w")
+          config.logger.stream = StringIO.new
 
           config.middleware.use Middlewares::AppendOne
           config.middleware.use Middlewares::Prepare, before: Middlewares::AppendOne
@@ -101,7 +102,7 @@ RSpec.describe "Hanami web app", :app_integration do
 
       module TestApp
         class App < Hanami::App
-          config.logger.stream = File.new("/dev/null", "w")
+          config.logger.stream = StringIO.new
         end
       end
     RUBY
@@ -164,7 +165,7 @@ RSpec.describe "Hanami web app", :app_integration do
         end
 
         class App < Hanami::App
-          config.logger.stream = File.new("/dev/null", "w")
+          config.logger.stream = StringIO.new
 
           config.middleware.use(TestApp::TestMiddleware) { |env| env["tested"] = "yes" }
         end
@@ -234,4 +235,427 @@ RSpec.describe "Hanami web app", :app_integration do
       }.to raise_error(Hanami::UnsupportedMiddlewareSpecError)
     end
   end
+
+  context "with simple app" do
+    before do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/authentication.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class Authentication
+              def self.inspect
+                "<Middleware::Auth>"
+              end
+
+              def initialize(app)
+                @app = app
+              end
+
+              def call(env)
+                env["AUTH_USER_ID"] = user_id = "23"
+                status, headers, body = @app.call(env)
+                headers["X-Auth-User-ID"] = user_id
+
+                [status, headers, body]
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        require "test_app/middleware/authentication"
+
+        module TestApp
+          class Routes < Hanami::Routes
+            root to: ->(*) { [200, {"Content-Length" => "4"}, ["Home"]] }
+
+            slice :admin, at: "/admin" do
+              use TestApp::Middleware::Authentication
+
+              root to: "home.show"
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/actions/home/show.rb", <<~RUBY
+        module Admin
+          module Actions
+            module Home
+              class Show < Hanami::Action
+                def handle(req, res)
+                  res.body = "Hello from admin (User ID " + req.env['AUTH_USER_ID'] + ")"
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/boot"
+    end
+
+    it "excludes root scope" do
+      get "/"
+
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq "Home"
+      expect(last_response.headers).to_not have_key("X-Auth-User-ID")
+    end
+
+    it "excludes not found routes in root scope" do
+      get "/foo"
+
+      expect(last_response.status).to eq 404
+      expect(last_response.body).to eq "Not Found"
+      expect(last_response.headers).to_not have_key("X-Auth-User-ID")
+    end
+
+    context "within slice" do
+      it "uses Rack middleware" do
+        get "/admin"
+
+        expect(last_response.status).to eq 200
+        expect(last_response.body).to eq "Hello from admin (User ID 23)"
+        expect(last_response.headers).to have_key("X-Auth-User-ID")
+      end
+
+      it "uses Rack middleware for not found paths" do
+        get "/admin/users"
+
+        expect(last_response.status).to be(404)
+        expect(last_response.body).to eq "Not Found"
+        expect(last_response.headers).to have_key("X-Auth-User-ID")
+      end
+    end
+  end
+
+  context "with complex app" do
+    let(:app_modules) { %i[TestApp Admin APIV1] }
+
+    before do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/elapsed.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class Elapsed
+              def self.inspect
+                "<Middleware::Elapsed>"
+              end
+
+              def initialize(app)
+                @app = app
+              end
+
+              def call(env)
+                with_time_instrumentation do
+                  @app.call(env)
+                end
+              end
+
+              private
+
+              def with_time_instrumentation
+                starting = now
+                status, headers, body = yield
+                ending = now
+
+                headers["X-Elapsed"] = (ending - starting).round(5).to_s
+                [status, headers, body]
+              end
+
+              def now
+                Process.clock_gettime(Process::CLOCK_MONOTONIC)
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/authentication.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class Authentication
+              def self.inspect
+                "<Middleware::Auth>"
+              end
+
+              def initialize(app)
+                @app = app
+              end
+
+              def call(env)
+                env["AUTH_USER_ID"] = user_id = "23"
+                status, headers, body = @app.call(env)
+                headers["X-Auth-User-ID"] = user_id
+
+                [status, headers, body]
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/rate_limiter.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class RateLimiter
+              def self.inspect
+                "<Middleware::API::Limiter>"
+              end
+
+              def initialize(app)
+                @app = app
+              end
+
+              def call(env)
+                status, headers, body = @app.call(env)
+                headers["X-API-Rate-Limit-Quota"] = "4000"
+
+                [status, headers, body]
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/api_version.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class ApiVersion
+              def self.inspect
+                "<Middleware::API::Version>"
+              end
+
+              def initialize(app)
+                @app = app
+              end
+
+              def call(env)
+                status, headers, body = @app.call(env)
+                headers["X-API-Version"] = "1"
+
+                [status, headers, body]
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/api_deprecation.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class ApiDeprecation
+              def self.inspect
+                "<Middleware::API::Deprecation>"
+              end
+
+              def initialize(app)
+                @app = app
+              end
+
+              def call(env)
+                status, headers, body = @app.call(env)
+                headers["X-API-Deprecated"] = "API v1 is deprecated"
+
+                [status, headers, body]
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "lib/test_app/middleware/scope_identifier.rb", <<~RUBY
+        module TestApp
+          module Middleware
+            class ScopeIdentifier
+              def self.inspect
+                "<Middleware::API::ScopeIdentifier>"
+              end
+
+              def initialize(app, scope)
+                @app = app
+                @scope = scope
+              end
+
+              def call(env)
+                status, header, body = @app.call(env)
+                header["X-Identifier-" + @scope] = "true"
+                [status, header, body]
+              end
+
+              def inspect
+                "Scope identifier: " + @scope.inspect
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        require "test_app/middleware/elapsed"
+        require "test_app/middleware/authentication"
+        require "test_app/middleware/rate_limiter"
+        require "test_app/middleware/api_version"
+        require "test_app/middleware/api_deprecation"
+        require "test_app/middleware/scope_identifier"
+
+        module TestApp
+          class Routes < Hanami::Routes
+            use TestApp::Middleware::Elapsed
+            use TestApp::Middleware::ScopeIdentifier, "Root"
+            root to: ->(*) { [200, {"Content-Length" => "4"}, ["Home (complex app)"]] }
+
+            mount ->(*) { [200, {"Content-Length" => "7"}, ["Mounted"]] }, at: "/mounted"
+
+            slice :admin, at: "/admin" do
+              use TestApp::Middleware::Authentication
+              use TestApp::Middleware::ScopeIdentifier, "Admin"
+
+              root to: "home.show"
+            end
+
+            # Without leading slash
+            # See: https://github.com/hanami/api/issues/8
+            scope "api" do
+              use TestApp::Middleware::RateLimiter
+              use TestApp::Middleware::ScopeIdentifier, "API"
+
+              root to: ->(*) { [200, {"Content-Length" => "3"}, ["API"]] }
+
+              slice :api_v1, at: "/v1" do
+                use TestApp::Middleware::ApiVersion
+                use TestApp::Middleware::ApiDeprecation
+                use TestApp::Middleware::ScopeIdentifier, "API-V1"
+
+                root to: "home.show"
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/actions/home/show.rb", <<~RUBY
+        module Admin
+          module Actions
+            module Home
+              class Show < Hanami::Action
+                def handle(req, res)
+                  res.body = "Hello from admin (User ID " + req.env['AUTH_USER_ID'] + ")"
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "slices/api_v1/actions/home/show.rb", <<~RUBY
+        module APIV1
+          module Actions
+            module Home
+              class Show < Hanami::Action
+                def handle(req, res)
+                  res.body = "API v1"
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/boot"
+    end
+
+    it "uses Rack middleware" do
+      get "/"
+
+      expect(last_response.status).to be(200)
+      expect(last_response.body).to eq("Home (complex app)")
+      expect(last_response.headers["X-Identifier-Root"]).to eq("true")
+      expect(last_response.headers).to have_key("X-Elapsed")
+      expect(last_response.headers).to_not have_key("X-Auth-User-ID")
+      expect(last_response.headers).to_not have_key("X-API-Rate-Limit-Quota")
+      expect(last_response.headers).to_not have_key("X-API-Version")
+    end
+
+    it "uses Rack middleware for other paths" do
+      get "/foo"
+
+      expect(last_response.status).to be(404)
+      expect(last_response.headers["X-Identifier-Root"]).to eq("true")
+      expect(last_response.headers).to have_key("X-Elapsed")
+      expect(last_response.headers).to_not have_key("X-Auth-User-ID")
+      expect(last_response.headers).to_not have_key("X-API-Rate-Limit-Quota")
+      expect(last_response.headers).to_not have_key("X-API-Version")
+    end
+
+    context "scoped" do
+      it "uses Rack middleware" do
+        get "/admin"
+
+        expect(last_response.status).to be(200)
+        expect(last_response.headers["X-Identifier-Admin"]).to eq("true")
+        expect(last_response.headers).to have_key("X-Elapsed")
+        expect(last_response.headers).to have_key("X-Auth-User-ID")
+        expect(last_response.headers).to_not have_key("X-API-Rate-Limit-Quota")
+        expect(last_response.headers).to_not have_key("X-API-Version")
+      end
+
+      it "uses Rack middleware for other paths" do
+        get "/admin/users"
+
+        expect(last_response.status).to be(404)
+        expect(last_response.headers["X-Identifier-Admin"]).to eq("true")
+        expect(last_response.headers).to have_key("X-Elapsed")
+        expect(last_response.headers).to have_key("X-Elapsed")
+        expect(last_response.headers).to have_key("X-Auth-User-ID")
+        expect(last_response.headers).to_not have_key("X-API-Rate-Limit-Quota")
+        expect(last_response.headers).to_not have_key("X-API-Version")
+      end
+
+      # See: https://github.com/hanami/api/issues/8
+      it "uses Rack middleware for scope w/o leading slash" do
+        get "/api"
+
+        expect(last_response.status).to be(200)
+        expect(last_response.headers["X-Identifier-Api"]).to eq("true")
+        expect(last_response.headers).to have_key("X-Elapsed")
+        expect(last_response.headers).to_not have_key("X-Auth-User-ID")
+        expect(last_response.headers).to have_key("X-API-Rate-Limit-Quota")
+        expect(last_response.headers).to_not have_key("X-API-Version")
+      end
+
+      # See: https://github.com/hanami/api/issues/8
+      it "uses Rack middleware for nested scope w/o leading slash" do
+        get "/api/v1"
+
+        expect(last_response.status).to be(200)
+        expect(last_response.headers["X-Identifier-API-V1"]).to eq("true")
+        expect(last_response.headers).to have_key("X-Elapsed")
+        expect(last_response.headers).to_not have_key("X-Auth-User-ID")
+        expect(last_response.headers).to have_key("X-API-Rate-Limit-Quota")
+        expect(last_response.headers).to have_key("X-API-Deprecated")
+        expect(last_response.headers["X-API-Version"]).to eq("1")
+      end
+    end
+  end
 end

data/spec/integration/rack_app/non_booted_rack_app_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack/test"
+require "stringio"
 
 RSpec.describe "Running a Rack app for a non-booted app", :app_integration do
   include Rack::Test::Methods
@@ -14,7 +15,7 @@ RSpec.describe "Running a Rack app for a non-booted app", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY

data/spec/integration/rack_app/rack_app_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack/test"
+require "stringio"
 
 RSpec.describe "Hanami web app", :app_integration do
   include Rack::Test::Methods
@@ -46,10 +47,25 @@ RSpec.describe "Hanami web app", :app_integration do
         end
       RUBY
 
+      write "app/actions/users/index.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Users
+              class Index < Hanami::Action
+                def handle(req, _resp)
+                  raise StandardError, "OH NOEZ"
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
       write "config/routes.rb", <<~RUBY
         module TestApp
           class Routes < Hanami::Routes
             root to: ->(env) { [200, {}, ["OK"]] }
+            get "/users", to: "users.index"
           end
         end
       RUBY
@@ -63,6 +79,14 @@ RSpec.describe "Hanami web app", :app_integration do
       logs = -> { Pathname(dir).join("test.log").realpath.read }
 
       expect(logs.()).to match %r{GET 200 \d+ms 127.0.0.1 /}
+
+      begin
+        get "/users"
+      rescue => e # rubocop:disable Style/RescueStandardError
+        raise unless e.to_s == "OH NOEZ"
+      end
+
+      expect(logs.()).to match %r{OH NOEZ}
     end
   end
 
@@ -109,7 +133,7 @@ RSpec.describe "Hanami web app", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY
@@ -214,7 +238,7 @@ RSpec.describe "Hanami web app", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY
@@ -279,7 +303,7 @@ RSpec.describe "Hanami web app", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
           end
         end
       RUBY
@@ -372,8 +396,9 @@ RSpec.describe "Hanami web app", :app_integration do
       require "hanami/boot"
 
       expect { Hanami.app.rack_app }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Slice::Routing::UnknownActionError)
-        expect(exception.message).to include("missing.action")
+        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
+        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in TestApp::App")
+        expect(exception.message).to match(%r{define the action class TestApp::Actions::Missing::Action.+actions/missing/action.rb})
       end
     end
   end
@@ -403,8 +428,9 @@ RSpec.describe "Hanami web app", :app_integration do
       require "hanami/boot"
 
       expect { Hanami.app.rack_app }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Slice::Routing::UnknownActionError)
-        expect(exception.message).to include("missing.action")
+        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
+        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in Admin::Slice")
+        expect(exception.message).to match(%r{define the action class Admin::Actions::Missing::Action.+slices/admin/actions/missing/action.rb})
       end
     end
   end
@@ -433,8 +459,9 @@ RSpec.describe "Hanami web app", :app_integration do
       expect { Hanami.app.rack_app }.not_to raise_error
 
       expect { get "/missing" }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Slice::Routing::UnknownActionError)
-        expect(exception.message).to include("missing.action")
+        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
+        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in TestApp::App")
+        expect(exception.message).to match(%r{define the action class TestApp::Actions::Missing::Action.+actions/missing/action.rb})
       end
     end
   end
@@ -466,8 +493,9 @@ RSpec.describe "Hanami web app", :app_integration do
       expect { Hanami.app.rack_app }.not_to raise_error
 
       expect { get "/admin/missing" }.to raise_error do |exception|
-        expect(exception).to be_kind_of(Hanami::Slice::Routing::UnknownActionError)
-        expect(exception.message).to include("missing.action")
+        expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
+        expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in Admin::Slice")
+        expect(exception.message).to match(%r{define the action class Admin::Actions::Missing::Action.+slices/admin/actions/missing/action.rb})
       end
     end
   end

data/spec/integration/setup_spec.rb

@@ -63,12 +63,12 @@ RSpec.describe "Hanami setup", :app_integration do
 
           with_tmp_directory(Dir.mktmpdir) do
             write "config/app.rb", <<~RUBY
-            require "hanami"
+              require "hanami"
 
-            module TestApp
-              class App < Hanami::App
+              module TestApp
+                class App < Hanami::App
+                end
               end
-            end
             RUBY
 
             expect { setup }.to change { Hanami.app? }.to true

data/spec/integration/slices/external_slice_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack/test"
+require "stringio"
 
 RSpec.describe "Slices / External slices", :app_integration do
   include Rack::Test::Methods
@@ -14,7 +15,7 @@ RSpec.describe "Slices / External slices", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
 
             require "external/slice"
             register_slice(:external, External::Slice)

data/spec/integration/slices/slice_configuration_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "stringio"
+
 RSpec.describe "Slices / Slice configuration", :app_integration do
   specify "Slices receive a copy of the app configuration, and can make distinct modifications" do
     with_tmp_directory(Dir.mktmpdir) do
@@ -8,7 +10,7 @@ RSpec.describe "Slices / Slice configuration", :app_integration do
 
         module TestApp
           class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
+            config.logger.stream = StringIO.new
 
             config.no_auto_register_paths << "structs"
           end

data/spec/integration/slices/slice_loading_spec.rb

@@ -3,7 +3,7 @@
 require "rack/test"
 
 RSpec.describe "Slices / Slice loading", :app_integration, :aggregate_failures do
-  let(:app_modules) { %i[TestApp Admin Editorial Main Shop] }
+  let(:app_modules) { %i[TestApp Admin Main] }
 
   describe "loading specific slices with config.slices" do
     describe "setup app" do
@@ -48,7 +48,7 @@ RSpec.describe "Slices / Slice loading", :app_integration, :aggregate_failures d
 
             expect { Admin::Slice.register_slice :editorial }.not_to(change { Admin::Slice.slices.keys })
             expect { Admin::Slice.register_slice :shop }.to change { Admin::Slice.slices.keys }.to [:shop]
-            expect(Shop::Slice).to be
+            expect(Admin::Shop::Slice).to be
           end
         end
       end
@@ -123,9 +123,9 @@ RSpec.describe "Slices / Slice loading", :app_integration, :aggregate_failures d
             expect(Admin::Slice.slices.keys).to eq [:shop]
 
             expect(Admin::Slice).to be
-            expect(Shop::Slice).to be
+            expect(Admin::Shop::Slice).to be
 
-            expect { Editorial }.to raise_error(NameError)
+            expect { Admin::Editorial }.to raise_error(NameError)
             expect { Main }.to raise_error(NameError)
           end
         end