hanami 2.1.0.beta1 → 2.1.0.beta2.1

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

@@ -317,7 +317,7 @@ RSpec.describe "Hanami web app", :app_integration do
     it "excludes not found routes in root scope" do
       get "/foo"
 
-      expect(last_response.status).to eq 500
+      expect(last_response.status).to eq 404
       expect(last_response.headers).to_not have_key("X-Auth-User-ID")
     end
 
@@ -333,7 +333,7 @@ RSpec.describe "Hanami web app", :app_integration do
       it "does not uses the Rack middleware for not found paths" do
         get "/admin/users"
 
-        expect(last_response.status).to eq 500
+        expect(last_response.status).to eq 404
         expect(last_response.headers).not_to have_key("X-Auth-User-ID")
       end
     end
@@ -600,7 +600,7 @@ RSpec.describe "Hanami web app", :app_integration do
     it "does not use Rack middleware for other paths" do
       get "/__not_found__"
 
-      expect(last_response.status).to eq 500
+      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")
@@ -623,7 +623,7 @@ RSpec.describe "Hanami web app", :app_integration do
       it "uses Rack middleware for other paths" do
         get "/admin/__not_found__"
 
-        expect(last_response.status).to eq 500
+        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")

data/spec/integration/rack_app/rack_app_spec.rb

@@ -33,227 +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|
-      @prev_hanami_env = ENV["HANAMI_ENV"]
-      ENV["HANAMI_ENV"] = "production"
-      example.run
-    ensure
-      ENV["HANAMI_ENV"] = @prev_hanami_env
-    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

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

data/spec/integration/view/context/assets_spec.rb

@@ -24,21 +24,15 @@ RSpec.describe "App view / Context / Assets", :app_integration do
 
   describe "#assets" do
     context "without assets provider" do
-      it "raises error" do
+      xit "raises error" do
+        allow(Hanami).to receive(:bundled?).with("hanami-assets").and_return(false)
+
         expect { context.assets }
           .to raise_error(Hanami::ComponentLoadError, /hanami-assets/)
       end
     end
 
     context "with assets provider" do
-      before do
-        Hanami.app.register_provider(:assets) do
-          start do
-            register "assets", Object.new
-          end
-        end
-      end
-
       it "is the app assets by default" do
         expect(context.assets).to be TestApp::App[:assets]
       end

data/spec/integration/web/render_detailed_errors_spec.rb

@@ -56,6 +56,15 @@ RSpec.describe "Web / Rendering detailed errors", :app_integration do
       expect(html).to have_selector("header", text: "RuntimeError at /error")
       expect(html).to have_selector("ul.frames li.application", text: "app/actions/error.rb")
     end
+
+    it "renders a detailed HTML error page and returns a 404 status for a not found error" do
+      get "/__not_found__", {}, "HTTP_ACCEPT" => "text/html"
+
+      expect(last_response.status).to eq 404
+
+      html = Capybara.string(last_response.body)
+      expect(html).to have_selector("header", text: "Hanami::Router::NotFoundError at /__not_found__")
+    end
   end
 
   describe "Other request types" do
@@ -67,6 +76,14 @@ RSpec.describe "Web / Rendering detailed errors", :app_integration do
       expect(last_response.body).to include "RuntimeError at /error"
       expect(last_response.body).to match %r{App backtrace.+app/actions/error.rb}m
     end
+
+    it "renders a detailed error page in text and returns a 404 status for a not found error" do
+      get "/__not_found__", {}, "HTTP_ACCEPT" => "text/html"
+
+      expect(last_response.status).to eq 404
+
+      expect(last_response.body).to include "Hanami::Router::NotFoundError at /__not_found__"
+    end
   end
 
   describe "render_detailed_errors config disabled" do

data/spec/integration/web/render_errors_spec.rb

@@ -225,12 +225,14 @@ RSpec.describe "Web / Rendering errors", :app_integration do
       HTML
     end
 
-    it "raises a Hanami::Router::NotFoundError for a 404" do
-      expect { get "/__not_found__" }.to raise_error(Hanami::Router::NotFoundError)
+    it "renders the hanami-router default 404 response for a not found error" do
+      get "/__not_found__"
+      expect(last_response.status).to eq 404
     end
 
-    it "raises a Hanami::Router::NotAllowedError for a 405" do
-      expect { post "/index" }.to raise_error(Hanami::Router::NotAllowedError)
+    it "renders the hanami-router default 405 response for a not allowed error" do
+      post "/index"
+      expect(last_response.status).to eq 405
     end
 
     it "raises the original error for a 500" do

data/spec/support/app_integration.rb

@@ -2,6 +2,7 @@
 
 require "hanami/devtools/integration/files"
 require "hanami/devtools/integration/with_tmp_directory"
+require "json"
 require "tmpdir"
 require "zeitwerk"
 
@@ -16,10 +17,52 @@ module RSpec
         end
       end
     end
+
+    module App
+      def self.included(base)
+        super
+
+        base.class_eval do
+          let!(:node_modules_path) { File.join(Dir.pwd, "node_modules") }
+        end
+      end
+
+      private
+
+      def stub_assets(*assets)
+        manifest_hash = assets.each_with_object({}) { |source_path, hsh|
+          hsh[source_path] = {url: File.join("/assets", source_path)}
+        }
+
+        write "public/assets.json", JSON.generate(manifest_hash)
+      end
+
+      def compile_assets!
+        link_node_modules
+
+        require "hanami/cli/command"
+        require "hanami/cli/commands/app/command"
+        require "hanami/cli/commands/app/assets/compile"
+        compiler = Hanami::CLI::Commands::App::Assets::Compile.new(config: Hanami.app.config.assets)
+
+        with_directory(Hanami.app.root) do
+          compiler.call
+        end
+      end
+
+      def link_node_modules
+        root = Hanami.app.root
+
+        return if File.exist?(File.join(root, "node_modules", "hanami-assets", "dist", "hanami-assets.js"))
+
+        FileUtils.ln_s(node_modules_path, root)
+      rescue Errno::EEXIST # rubocop:disable Lint/SuppressedException
+      end
+    end
   end
 end
 
-RSpec.shared_context "Application integration" do
+RSpec.shared_context "App integration" do
   let(:app_modules) { %i[TestApp Admin Main Search] }
 end
 
@@ -35,7 +78,8 @@ end
 RSpec.configure do |config|
   config.include RSpec::Support::Files, :app_integration
   config.include RSpec::Support::WithTmpDirectory, :app_integration
-  config.include_context "Application integration", :app_integration
+  config.include RSpec::Support::App, :app_integration
+  config.include_context "App integration", :app_integration
 
   config.before :each, :app_integration do
     # Conditionally assign these in case they have been assigned earlier for specific