hanami 2.0.3 → 2.1.0.beta2

data/spec/integration/web/render_errors_spec.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "json"
+require "rack/test"
+
+RSpec.describe "Web / Rendering errors", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Hanami.app }
+
+  before do
+    with_directory(@dir = make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+            config.render_errors = true
+            config.render_detailed_errors = false
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            get "index", to: "index"
+            get "error", to: "error"
+          end
+        end
+      RUBY
+
+      write "app/actions/index.rb", <<~RUBY
+        module TestApp
+          module Actions
+            class Index < Hanami::Action
+              def handle(*, response)
+                response.body = "Hello"
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/actions/error.rb", <<~RUBY
+        module TestApp
+          module Actions
+            class Error < Hanami::Action
+              def handle(*)
+                raise "oops"
+              end
+            end
+          end
+        end
+      RUBY
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  describe "HTML request" do
+    context "error pages present" do
+      def before_prepare
+        write "public/404.html", <<~HTML
+          <h1>Not found</h1>
+        HTML
+
+        write "public/500.html", <<~HTML
+          <h1>Error</h1>
+        HTML
+      end
+
+      it "responds with the HTML for a 404 from a not found error" do
+        get "/__not_found__"
+
+        expect(last_response.status).to eq 404
+        expect(last_response.body.strip).to eq "<h1>Not found</h1>"
+        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
+        expect(last_response.get_header("Content-Length")).to eq "19"
+      end
+
+      it "responds with the HTML for a 404 from a method not allowed error" do
+        post "/index"
+
+        expect(last_response.status).to eq 404
+        expect(last_response.body.strip).to eq "<h1>Not found</h1>"
+        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
+        expect(last_response.get_header("Content-Length")).to eq "19"
+      end
+
+      it "responds with the HTML for a 500" do
+        get "/error"
+
+        expect(last_response.status).to eq 500
+        expect(last_response.body.strip).to eq "<h1>Error</h1>"
+        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
+        expect(last_response.get_header("Content-Length")).to eq "15"
+      end
+    end
+
+    context "error pages missing" do
+      it "responds with default text for a 404 from a not found error" do
+        get "/__not_found__"
+
+        expect(last_response.status).to eq 404
+        expect(last_response.body.strip).to eq "Not Found"
+        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
+        expect(last_response.get_header("Content-Length")).to eq "9"
+      end
+
+      it "responds with default text for a 404 from a metohd not allowed error" do
+        post "/index"
+
+        expect(last_response.status).to eq 404
+        expect(last_response.body.strip).to eq "Not Found"
+        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
+        expect(last_response.get_header("Content-Length")).to eq "9"
+      end
+
+      it "responds with default text for a 500" do
+        get "/error"
+
+        expect(last_response.status).to eq 500
+        expect(last_response.body.strip).to eq "Internal Server Error"
+        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
+        expect(last_response.get_header("Content-Length")).to eq "21"
+      end
+    end
+  end
+
+  describe "JSON request" do
+    it "renders a JSON response for a 404 from a not found error" do
+      get "/__not_found__", {}, "HTTP_ACCEPT" => "application/json"
+
+      expect(last_response.status).to eq 404
+      expect(last_response.body.strip).to eq %({"status":404,"error":"Not Found"})
+      expect(last_response.get_header("Content-Type")).to eq "application/json; charset=utf-8"
+      expect(last_response.get_header("Content-Length")).to eq "34"
+    end
+
+    it "renders a JSON response for a 404 from a metnod not allowed error" do
+      post "/index", {}, "HTTP_ACCEPT" => "application/json"
+
+      expect(last_response.status).to eq 404
+      expect(last_response.body.strip).to eq %({"status":404,"error":"Not Found"})
+      expect(last_response.get_header("Content-Type")).to eq "application/json; charset=utf-8"
+      expect(last_response.get_header("Content-Length")).to eq "34"
+    end
+
+    it "renders a JSON response for a 500" do
+      get "/error", {}, "HTTP_ACCEPT" => "application/json"
+
+      expect(last_response.status).to eq 500
+      expect(last_response.body.strip).to eq %({"status":500,"error":"Internal Server Error"})
+      expect(last_response.get_header("Content-Type")).to eq "application/json; charset=utf-8"
+      expect(last_response.get_header("Content-Length")).to eq "46"
+    end
+  end
+
+  describe "configuring error responses" do
+    def before_prepare
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          CustomNotFoundError = Class.new(StandardError)
+
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+            config.render_errors = true
+            config.render_error_responses["TestApp::CustomNotFoundError"] = :not_found
+            config.render_detailed_errors = false
+          end
+        end
+      RUBY
+
+      write "app/actions/error.rb", <<~RUBY
+        module TestApp
+          module Actions
+            class Error < Hanami::Action
+              def handle(*)
+                raise CustomNotFoundError
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "public/404.html", <<~HTML
+        <h1>Not found</h1>
+      HTML
+    end
+
+    it "uses the configured errors to determine the response" do
+      get "/error"
+
+      expect(last_response.status).to eq 404
+      expect(last_response.body.strip).to eq "<h1>Not found</h1>"
+    end
+  end
+
+  describe "render_errors config disabled" do
+    def before_prepare
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+            config.render_errors = false
+            config.render_detailed_errors = false
+          end
+        end
+      RUBY
+
+      # Include error pages here to prove they are _not_ used
+      write "public/404.html", <<~HTML
+        <h1>Not found</h1>
+      HTML
+
+      write "public/500.html", <<~HTML
+        <h1>Error</h1>
+      HTML
+    end
+
+    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 "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
+      expect { get "/error" }.to raise_error(RuntimeError, "oops")
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -23,6 +23,6 @@ RSpec.configure do |config|
     # TODO: Find out what causes logger to create this dir when running specs.
     #       There's probably a test app class being created somewhere with root
     #       not pointing to a tmp dir.
-    FileUtils.rm_r(LOG_DIR) if LOG_DIR.exist?
+    FileUtils.rm_rf(LOG_DIR) if LOG_DIR.exist?
   end
 end

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

data/spec/support/matchers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Support
+    module Matchers
+      module HTML
+        def squish_html(str)
+          str
+            .gsub(/^[[:space:]]+/, "")
+            .gsub(/>[[:space:]]+</m, "><")
+            .strip
+        end
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :eq_html do |expected_html|
+  include RSpec::Support::Matchers::HTML
+
+  match do |actual_html|
+    squish_html(actual_html) == squish_html(expected_html)
+  end
+end
+
+RSpec::Matchers.define :include_html do |expected_html|
+  include RSpec::Support::Matchers::HTML
+
+  match do |actual_html|
+    squish_html(actual_html).include?(squish_html(expected_html))
+  end
+end

data/spec/unit/hanami/config/actions/content_security_policy_spec.rb

@@ -3,43 +3,31 @@
 require "hanami/config/actions"
 
 RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
-  let(:config) { described_class.new }
+  let(:app_config) { Hanami::Config.new(app_name: "MyApp::App", env: :development) }
+  let(:config) { app_config.actions }
   subject(:content_security_policy) { config.content_security_policy }
 
   context "no CSP config specified" do
-    context "without assets_server_url" do
-
-      it "has defaults" do
-        expect(content_security_policy[:base_uri]).to eq("'self'")
-
-        expected = [
-          %(base-uri 'self'),
-          %(child-src 'self'),
-          %(connect-src 'self'),
-          %(default-src 'none'),
-          %(font-src 'self'),
-          %(form-action 'self'),
-          %(frame-ancestors 'self'),
-          %(frame-src 'self'),
-          %(img-src 'self' https: data:),
-          %(media-src 'self'),
-          %(object-src 'none'),
-          %(script-src 'self'),
-          %(style-src 'self' 'unsafe-inline' https:)
-        ].join(";")
-
-        expect(content_security_policy.to_s).to eq(expected)
-      end
-    end
-
-    context "with assets_server_url" do
-      let(:config) { described_class.new(assets_server_url: assets_server_url) }
-      let(:assets_server_url) { "http://localhost:8080" }
-
-      it "includes server url" do
-        expect(content_security_policy[:script_src]).to eq("'self' #{assets_server_url}")
-        expect(content_security_policy[:style_src]).to eq("'self' 'unsafe-inline' https: #{assets_server_url}")
-      end
+    it "has defaults" do
+      expect(content_security_policy[:base_uri]).to eq("'self'")
+
+      expected = [
+        %(base-uri 'self'),
+        %(child-src 'self'),
+        %(connect-src 'self'),
+        %(default-src 'none'),
+        %(font-src 'self'),
+        %(form-action 'self'),
+        %(frame-ancestors 'self'),
+        %(frame-src 'self'),
+        %(img-src 'self' https: data:),
+        %(media-src 'self'),
+        %(object-src 'none'),
+        %(script-src 'self'),
+        %(style-src 'self' 'unsafe-inline' https:)
+      ].join(";")
+
+      expect(content_security_policy.to_s).to eq(expected)
     end
   end
 
@@ -84,7 +72,7 @@ RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
 
   context "with CSP enabled" do
     it "sets default header" do
-      config.finalize!
+      app_config.finalize!
 
       expect(config.default_headers.fetch("Content-Security-Policy")).to eq(content_security_policy.to_s)
     end
@@ -93,7 +81,7 @@ RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
   context "with CSP disabled" do
     it "doesn't set default header" do
       config.content_security_policy = false
-      config.finalize!
+      app_config.finalize!
 
       expect(config.default_headers.key?("Content-Security-Policy")).to be(false)
     end

data/spec/unit/hanami/config/actions/csrf_protection_spec.rb

@@ -3,7 +3,8 @@
 require "hanami/config/actions"
 
 RSpec.describe Hanami::Config::Actions, "#csrf_protection" do
-  let(:config) { described_class.new }
+  let(:app_config) { Hanami::Config.new(app_name: "MyApp::App", env: :development) }
+  let(:config) { app_config.actions }
   subject(:value) { config.csrf_protection }
 
   context "non-finalized config" do
@@ -26,7 +27,7 @@ RSpec.describe Hanami::Config::Actions, "#csrf_protection" do
     context "sessions enabled" do
       before do
         config.sessions = :cookie, {secret: "abc"}
-        config.finalize!
+        app_config.finalize!
       end
 
       it "is true" do
@@ -46,7 +47,7 @@ RSpec.describe Hanami::Config::Actions, "#csrf_protection" do
 
     context "sessions not enabled" do
       before do
-        config.finalize!
+        app_config.finalize!
       end
 
       it "is true" do

data/spec/unit/hanami/config/actions/default_values_spec.rb

@@ -3,7 +3,8 @@
 require "hanami/config/actions"
 
 RSpec.describe Hanami::Config::Actions, "default values" do
-  subject(:config) { described_class.new }
+  let(:app_config) { Hanami::Config.new(app_name: "MyApp::App", env: :development) }
+  subject(:config) { app_config.actions }
 
   describe "sessions" do
     specify { expect(config.sessions).not_to be_enabled }
@@ -13,10 +14,6 @@ RSpec.describe Hanami::Config::Actions, "default values" do
     specify { expect(config.name_inference_base).to eq "actions" }
   end
 
-  describe "view_context_identifier" do
-    specify { expect(config.view_context_identifier).to eq "views.context" }
-  end
-
   describe "view_name_inferrer" do
     specify { expect(config.view_name_inferrer).to eq Hanami::Slice::ViewNameInferrer }
   end
@@ -32,7 +29,7 @@ RSpec.describe Hanami::Config::Actions, "default values" do
 
     describe "default_headers" do
       specify {
-        config.finalize!
+        app_config.finalize!
 
         expect(config.default_headers).to eq(
           "X-Frame-Options" => "DENY",

data/spec/unit/hanami/config/render_detailed_errors_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+RSpec.describe Hanami::Config, "#render_detailed_errors" do
+  let(:config) { described_class.new(app_name: app_name, env: env) }
+  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::App"), inflector: Dry::Inflector.new) }
+
+  subject(:render_detailed_errors) { config.render_detailed_errors }
+
+  context "development mode" do
+    let(:env) { :development }
+    it { is_expected.to be true }
+  end
+
+  context "test mode" do
+    let(:env) { :test }
+    it { is_expected.to be true }
+  end
+
+  context "production mode" do
+    let(:env) { :production }
+    it { is_expected.to be false }
+  end
+end

data/spec/unit/hanami/config/render_errors_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+
+RSpec.describe Hanami::Config, "#render_errors" do
+  let(:config) { described_class.new(app_name: app_name, env: env) }
+  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::App"), inflector: Dry::Inflector.new) }
+
+  subject(:render_errors) { config.render_errors }
+
+  context "development mode" do
+    let(:env) { :development }
+    it { is_expected.to be false }
+  end
+
+  context "test mode" do
+    let(:env) { :test }
+    it { is_expected.to be false }
+  end
+
+  context "production mode" do
+    let(:env) { :production }
+    it { is_expected.to be true }
+  end
+end

data/spec/unit/hanami/config/views_spec.rb

@@ -39,20 +39,6 @@ RSpec.describe Hanami::Config, "#views" do
     end
 
     describe "specialised default values" do
-      describe "paths" do
-        it 'is ["templates"]' do
-          expect(views.paths).to match [
-            an_object_satisfying { |path| path.dir.to_s == "templates" }
-          ]
-        end
-      end
-
-      describe "template_inference_base" do
-        it 'is "views"' do
-          expect(views.template_inference_base).to eq "views"
-        end
-      end
-
       describe "layout" do
         it 'is "app"' do
           expect(views.layout).to eq "app"
@@ -69,10 +55,6 @@ RSpec.describe Hanami::Config, "#views" do
         expect(views).to be_frozen
       end
 
-      it "does not allow changes to locally defined settings" do
-        expect { views.parts_path = "parts" }.to raise_error(Dry::Configurable::FrozenConfigError)
-      end
-
       it "does not allow changes to base view settings" do
         expect { views.paths = [] }.to raise_error(Dry::Configurable::FrozenConfigError)
       end

data/spec/unit/hanami/env_spec.rb

@@ -1,54 +1,40 @@
 # frozen_string_literal: true
 
 RSpec.describe Hanami, ".env" do
-  subject(:env) { described_class.env }
-
-  before do
-    @orig_env = ENV.to_h
-  end
-
-  after do
-    ENV.replace(@orig_env)
-  end
+  subject { described_class.env(e: env) }
 
   context "HANAMI_ENV in ENV" do
-    before do
-      ENV["HANAMI_ENV"] = "test"
-    end
+    let(:env) { {"HANAMI_ENV" => "test"} }
 
     it "is the value of HANAMI_ENV" do
-      is_expected.to eq :test
+      is_expected.to eq(:test)
     end
   end
 
   context "RACK_ENV in ENV" do
-    before do
-      ENV["RACK_ENV"] = "test"
-    end
+    let(:env) { {"HANAMI_ENV" => "test"} }
 
     it "is the value of RACK_ENV" do
-      is_expected.to eq :test
+      is_expected.to eq(:test)
     end
   end
 
   context "both HANAMI_ENV and RACK_ENV in ENV" do
-    before do
-      ENV["HANAMI_ENV"] = "test"
-      ENV["RACK_ENV"] = "production"
+    let(:env) do
+      {"HANAMI_ENV" => "test",
+       "RACK_ENV" => "production"}
     end
 
     it "is the value of HANAMI_ENV" do
-      is_expected.to eq :test
+      is_expected.to eq(:test)
     end
   end
 
   context "no ENV vars set" do
-    before do
-      ENV.delete("HANAMI_ENV")
-    end
+    let(:env) { {} }
 
     it "defaults to \"development\"" do
-      is_expected.to eq :development
+      is_expected.to eq(:development)
     end
   end
 end