hanami 2.0.3 → 2.1.0.beta2

data/spec/integration/logging/notifications_spec.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Logging / Notifications", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  specify "Request logging continues even when notifications bus has already been used" do
+    dir = Dir.mktmpdir
+
+    with_tmp_directory(dir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.actions.format :json
+            config.logger.options = {colorize: true}
+            config.logger.stream = config.root.join("test.log")
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            post "/users", to: "users.create"
+          end
+        end
+      RUBY
+
+      write "app/actions/users/create.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Users
+              class Create < Hanami::Action
+                def handle(req, resp)
+                  resp.body = req.params.to_h.keys
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      # Simulate any component interacting with the notifications bus such that it creates its
+      # internal bus with a duplicate copy of all currently registered events. This means that the
+      # class-level Dry::Monitor::Notification events implicitly registered by the
+      # Dry::Monitor::Rack::Middleware activated via the rack provider are ignored, unless our
+      # provider explicitly re-registers them on _instance_ of the notifications bus.
+      #
+      # See Hanami::Providers::Rack for more detail.
+      Hanami.app["notifications"].instrument(:sql)
+
+      logs = -> { Pathname(dir).join("test.log").realpath.read }
+
+      post "/users", JSON.generate(name: "jane", password: "secret"), {"CONTENT_TYPE" => "application/json"}
+      expect(logs.()).to match %r{POST 200 \d+(µs|ms) 127.0.0.1 /}
+    end
+  end
+end
+
+
+

data/spec/integration/logging/request_logging_spec.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack/test"
+require "stringio"
+
+RSpec.describe "Logging / Request logging", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  let(:logger_stream) { StringIO.new }
+
+  def configure_logger
+    Hanami.app.config.logger.stream = logger_stream
+  end
+
+  def logs
+    @logs ||= (logger_stream.rewind and logger_stream.read)
+  end
+
+  before do
+    with_directory(make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      require "hanami/setup"
+      configure_logger
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  describe "app router" do
+    def before_prepare
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            root to: ->(env) { [200, {}, ["OK"]] }
+          end
+        end
+      RUBY
+    end
+
+    it "logs the requests" do
+      get "/"
+
+      expect(logs.split("\n").length).to eq 1
+      expect(logs).to match %r{GET 200 \d+(µs|ms) 127.0.0.1 /}
+    end
+
+    context "production env" do
+      around do |example|
+        @prev_hanami_env = ENV["HANAMI_ENV"]
+        ENV["HANAMI_ENV"] = "production"
+        example.run
+      ensure
+        ENV["HANAMI_ENV"] = @prev_hanami_env
+      end
+
+      it "logs the requests as JSON" do
+        get "/"
+
+        expect(logs.split("\n").length).to eq 1
+
+        json = JSON.parse(logs, symbolize_names: true)
+        expect(json).to include(
+          verb: "GET",
+          path: "/",
+          ip: "127.0.0.1",
+          elapsed: Integer,
+          elapsed_unit: a_string_matching(/(µs|ms)/),
+        )
+      end
+    end
+  end
+
+  describe "slice router" do
+    let(:app) { Main::Slice.rack_app }
+
+    def before_prepare
+      write "slices/main/config/routes.rb", <<~RUBY
+        module Main
+          class Routes < Hanami::Routes
+            root to: ->(env) { [200, {}, ["OK"]] }
+          end
+        end
+      RUBY
+    end
+
+    it "logs the requests" do
+      get "/"
+
+      expect(logs.split("\n").length).to eq 1
+      expect(logs).to match %r{GET 200 \d+(µs|ms) 127.0.0.1 /}
+    end
+
+    context "production env" do
+      around do |example|
+        @prev_hanami_env = ENV["HANAMI_ENV"]
+        ENV["HANAMI_ENV"] = "production"
+        example.run
+      ensure
+        ENV["HANAMI_ENV"] = @prev_hanami_env
+      end
+
+      it "logs the requests as JSON" do
+        get "/"
+
+        expect(logs.split("\n").length).to eq 1
+
+        json = JSON.parse(logs, symbolize_names: true)
+        expect(json).to include(
+          verb: "GET",
+          path: "/",
+          ip: "127.0.0.1",
+          elapsed: Integer,
+          elapsed_unit: a_string_matching(/(µs|ms)/),
+        )
+      end
+    end
+  end
+end

data/spec/integration/rack_app/middleware_spec.rb

@@ -244,6 +244,7 @@ RSpec.describe "Hanami web app", :app_integration do
         module TestApp
           class App < Hanami::App
             config.logger.stream = File.new("/dev/null", "w")
+            config.render_errors = true
           end
         end
       RUBY
@@ -317,7 +318,6 @@ RSpec.describe "Hanami web app", :app_integration 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
 
@@ -330,12 +330,11 @@ RSpec.describe "Hanami web app", :app_integration do
         expect(last_response.headers).to have_key("X-Auth-User-ID")
       end
 
-      it "uses Rack middleware for not found paths" do
+      it "does not uses the 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")
+        expect(last_response.status).to eq 404
+        expect(last_response.headers).not_to have_key("X-Auth-User-ID")
       end
     end
   end
@@ -350,6 +349,7 @@ RSpec.describe "Hanami web app", :app_integration do
         module TestApp
           class App < Hanami::App
             config.logger.stream = File.new("/dev/null", "w")
+            config.render_errors = true
           end
         end
       RUBY
@@ -597,15 +597,15 @@ RSpec.describe "Hanami web app", :app_integration do
       expect(last_response.headers).to_not have_key("X-API-Version")
     end
 
-    it "uses Rack middleware for other paths" do
-      get "/foo"
+    it "does not use Rack middleware for other paths" do
+      get "/__not_found__"
 
-      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")
+      expect(last_response.status).to eq 404
+      expect(last_response.headers).not_to have_key("X-Identifier-Root")
+      expect(last_response.headers).not_to have_key("X-Elapsed")
+      expect(last_response.headers).not_to have_key("X-Auth-User-ID")
+      expect(last_response.headers).not_to have_key("X-API-Rate-Limit-Quota")
+      expect(last_response.headers).not_to have_key("X-API-Version")
     end
 
     context "scoped" do
@@ -621,15 +621,15 @@ RSpec.describe "Hanami web app", :app_integration do
       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")
+        get "/admin/__not_found__"
+
+        expect(last_response.status).to eq 404
+        expect(last_response.headers).not_to have_key("X-Identifier-Admin")
+        expect(last_response.headers).not_to have_key("X-Elapsed")
+        expect(last_response.headers).not_to have_key("X-Elapsed")
+        expect(last_response.headers).not_to have_key("X-Auth-User-ID")
+        expect(last_response.headers).not_to have_key("X-API-Rate-Limit-Quota")
+        expect(last_response.headers).not_to have_key("X-API-Version")
       end
 
       # See: https://github.com/hanami/api/issues/8

data/spec/integration/rack_app/rack_app_spec.rb

@@ -33,226 +33,6 @@ RSpec.describe "Hanami web app", :app_integration do
     end
   end
 
-  specify "Has rack monitor preconfigured with default request logging" do
-    dir = Dir.mktmpdir
-
-    with_tmp_directory(dir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.actions.format :json
-            config.logger.options = {colorize: true}
-            config.logger.stream = config.root.join("test.log")
-          end
-        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 "app/actions/users/create.rb", <<~RUBY
-        module TestApp
-          module Actions
-            module Users
-              class Create < Hanami::Action
-                def handle(req, resp)
-                  resp.body = req.params.to_h.keys
-                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"
-            post "/users", to: "users.create"
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      expect(Hanami.app["rack.monitor"]).to be_instance_of(Dry::Monitor::Rack::Middleware)
-
-      get "/"
-
-      logs = -> { Pathname(dir).join("test.log").realpath.read }
-
-      expect(logs.()).to match %r{GET 200 \d+(µs|ms) 127.0.0.1 /}
-
-      post "/users", JSON.generate(name: "jane", password: "secret"), {"CONTENT_TYPE" => "application/json"}
-
-      expect(logs.()).to match %r{POST 200 \d+(µs|ms) 127.0.0.1 /}
-
-      begin
-        get "/users"
-      rescue => e # rubocop:disable Style/RescueStandardError
-        raise unless e.to_s == "OH NOEZ"
-      end
-
-      err_log = logs.()
-
-      expect(err_log).to include("OH NOEZ")
-      expect(err_log).to include("app/actions/users/index.rb:6:in `handle'")
-    end
-  end
-
-  specify "Logging via the rack monitor even when notifications bus has already been used" do
-    dir = Dir.mktmpdir
-
-    with_tmp_directory(dir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.actions.format :json
-            config.logger.options = {colorize: true}
-            config.logger.stream = config.root.join("test.log")
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            post "/users", to: "users.create"
-          end
-        end
-      RUBY
-
-      write "app/actions/users/create.rb", <<~RUBY
-        module TestApp
-          module Actions
-            module Users
-              class Create < Hanami::Action
-                def handle(req, resp)
-                  resp.body = req.params.to_h.keys
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      # Simulate any component interacting with the notifications bus such that it creates its
-      # internal bus with a duplicate copy of all currently registered events. This means that the
-      # class-level Dry::Monitor::Notification events implicitly registered by the
-      # Dry::Monitor::Rack::Middleware activated via the rack provider are ignored, unless our
-      # provider explicitly re-registers them on _instance_ of the notifications bus.
-      #
-      # See Hanami::Providers::Rack for more detail.
-      Hanami.app["notifications"].instrument(:sql)
-
-      logs = -> { Pathname(dir).join("test.log").realpath.read }
-
-      post "/users", JSON.generate(name: "jane", password: "secret"), {"CONTENT_TYPE" => "application/json"}
-      expect(logs.()).to match %r{POST 200 \d+(µs|ms) 127.0.0.1 /}
-    end
-  end
-
-  describe "Request logging when using slice router" do
-    let(:app) { Main::Slice.rack_app }
-
-    specify "Has rack monitor preconfigured with default request logging (when used via a slice)" do
-      dir = Dir.mktmpdir
-
-      with_tmp_directory(dir) do
-        write "config/app.rb", <<~RUBY
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-              config.logger.stream = config.root.join("test.log")
-            end
-          end
-        RUBY
-
-        write "slices/main/config/routes.rb", <<~RUBY
-          module Main
-            class Routes < Hanami::Routes
-              root to: ->(env) { [200, {}, ["OK"]] }
-            end
-          end
-        RUBY
-
-        require "hanami/prepare"
-
-        get "/"
-
-        logs = -> { Pathname(dir).join("test.log").realpath.read }
-
-        expect(logs.()).to match %r{GET 200 \d+(µs|ms) 127.0.0.1 /}
-      end
-    end
-  end
-
-  describe "Request logging on production" do
-    let(:app) { Main::Slice.rack_app }
-
-    around do |example|
-      ENV["HANAMI_ENV"] = "production"
-      example.run
-    ensure
-      ENV["HANAMI_ENV"] = "test"
-    end
-
-    specify "Has rack monitor preconfigured with default request logging (when used via a slice)" do
-      dir = Dir.mktmpdir
-
-      with_tmp_directory(dir) do
-        write "config/app.rb", <<~RUBY
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-              config.logger.stream = config.root.join("test.log")
-            end
-          end
-        RUBY
-
-        write "slices/main/config/routes.rb", <<~RUBY
-          module Main
-            class Routes < Hanami::Routes
-              root to: ->(env) { [200, {}, ["OK"]] }
-            end
-          end
-        RUBY
-
-        require "hanami/boot"
-
-        get "/"
-
-        logs = -> { Pathname(dir).join("test.log").realpath.read }
-
-        log_content = logs.()
-
-        expect(log_content).to match(%r["verb":"GET"])
-        expect(log_content).to match(%r["path":"/"])
-        expect(log_content).to match(%r[elapsed":\d+,"elapsed_unit":"µs"])
-      end
-    end
-  end
-
   specify "Routing to actions based on their container identifiers" do
     with_tmp_directory(Dir.mktmpdir) do
       write "config/app.rb", <<~RUBY
@@ -569,6 +349,7 @@ RSpec.describe "Hanami web app", :app_integration do
 
         module TestApp
           class App < Hanami::App
+            config.render_detailed_errors = false
           end
         end
       RUBY
@@ -600,6 +381,8 @@ RSpec.describe "Hanami web app", :app_integration do
 
         module TestApp
           class App < Hanami::App
+            config.render_detailed_errors = false
+
             register_slice :admin
           end
         end

data/spec/integration/rake_tasks_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "rake"
+require "hanami/cli/bundler"
+
+RSpec.describe "Rake tasks", :app_integration do
+  describe "assets:precompile" do
+    before do
+      allow(Hanami).to receive(:bundled?)
+      allow(Hanami).to receive(:bundled?).with("hanami-assets").and_return(hanami_assets_bundled)
+    end
+
+    context "when hanami-assets is bundled" do
+      let(:hanami_assets_bundled) { true }
+
+      xit "compiles assets" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write "Rakefile", <<~RUBY
+            # frozen_string_literal: true
+
+            require "hanami/rake_tasks"
+          RUBY
+
+          write "app/assets/js/app.js", <<~JS
+            console.log("Hello from index.js");
+          JS
+
+          before_prepare if respond_to?(:before_prepare)
+          require "hanami/prepare"
+
+          expect_any_instance_of(Hanami::CLI::Bundler).to receive(:hanami_exec).with("assets compile").and_return(true)
+
+          Rake::Task["assets:precompile"].invoke
+        end
+      end
+
+      it "doesn't list the task" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write "Rakefile", <<~RUBY
+            # frozen_string_literal: true
+
+            require "hanami/rake_tasks"
+          RUBY
+
+          before_prepare if respond_to?(:before_prepare)
+          require "hanami/prepare"
+
+          output = `bundle exec rake -T`
+          expect(output).to_not include("assets:precompile")
+        end
+      end
+    end
+
+    context "when hanami-assets is not bundled" do
+      let(:hanami_assets_bundled) { false }
+
+      it "raises error" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write "Rakefile", <<~RUBY
+            # frozen_string_literal: true
+
+            require "hanami/rake_tasks"
+          RUBY
+
+          write "app/assets/js/app.js", <<~JS
+            console.log("Hello from index.js");
+          JS
+
+          before_prepare if respond_to?(:before_prepare)
+          require "hanami/prepare"
+
+          expect { Rake::Task["assets:precompile"].invoke }.to raise_error do |exception|
+            expect(exception).to be_a(RuntimeError)
+            expect(exception.message).to match(/Don't know how to build task 'assets:precompile'/)
+          end
+        end
+      end
+    end
+  end
+end