hanami 2.0.3 → 2.1.0.beta1

data/spec/integration/web/render_errors_spec.rb

@@ -0,0 +1,240 @@
+# 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 "raises a Hanami::Router::NotFoundError for a 404" do
+      expect { get "/__not_found__" }.to raise_error(Hanami::Router::NotFoundError)
+    end
+
+    it "raises a Hanami::Router::NotAllowedError for a 405" do
+      expect { post "/index" }.to raise_error(Hanami::Router::NotAllowedError)
+    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/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/default_values_spec.rb

@@ -13,10 +13,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

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/extensions/view/context_spec.rb

@@ -0,0 +1,59 @@
+require "hanami/view"
+require "hanami/view/context"
+require "hanami/extensions/view/context"
+
+RSpec.describe(Hanami::View::Context) do
+  subject(:context) { described_class.new(**args) }
+  let(:args) { {} }
+
+  describe "#assets" do
+    context "assets given" do
+      let(:args) { {assets: assets} }
+      let(:assets) { double(:assets) }
+
+      it "returns the assets" do
+        expect(context.assets).to be assets
+      end
+    end
+
+    context "no assets given" do
+      it "raises a Hanami::ComponentLoadError" do
+        expect { context.assets }.to raise_error Hanami::ComponentLoadError
+      end
+    end
+  end
+
+  describe "#request" do
+    context "request given" do
+      let(:args) { {request: request} }
+      let(:request) { double(:request) }
+
+      it "returns the request" do
+        expect(context.request).to be request
+      end
+    end
+
+    context "no request given" do
+      it "raises a Hanami::ComponentLoadError" do
+        expect { context.request }.to raise_error Hanami::ComponentLoadError
+      end
+    end
+  end
+
+  describe "#routes" do
+    context "routes given" do
+      let(:args) { {routes: routes} }
+      let(:routes) { double(:routes) }
+
+      it "returns the routes" do
+        expect(context.routes).to be routes
+      end
+    end
+
+    context "no routes given" do
+      it "raises a Hanami::ComponentLoadError" do
+        expect { context.routes }.to raise_error Hanami::ComponentLoadError
+      end
+    end
+  end
+end