hanami 2.0.3 → 2.1.0.beta1

data/spec/integration/action/view_rendering/view_context_spec.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+RSpec.describe "App action / View rendering / View context", :app_integration do
+  subject(:context) {
+    # We capture the context during rendering via our view spies; see the view classes below
+    action.call("REQUEST_METHOD" => "GET", "QUERY_STRING" => "/mock_request")
+    action.view.called_with[:context]
+  }
+
+  before do
+    with_directory(make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/action.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/view"
+
+        module TestApp
+          class Action < Hanami::Action
+          end
+        end
+      RUBY
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  describe "app action" do
+    let(:action) { TestApp::App["actions.posts.show"] }
+
+    def before_prepare
+      write "app/actions/posts/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Posts
+              class Show < TestApp::Action
+              end
+            end
+          end
+        end
+      RUBY
+
+      # Custom view class as a spy for `#call` args
+      write "app/views/posts/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Posts
+              class Show
+                attr_reader :called_with
+
+                def call(**args)
+                  @called_with = args
+                  ""
+                end
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    context "no context class defined" do
+      it "defines and uses a context class" do
+        expect(context).to be_an_instance_of TestApp::Views::Context
+        expect(context.class).to be < Hanami::View::Context
+      end
+
+      it "includes the request" do
+        expect(context.request).to be_an_instance_of Hanami::Action::Request
+        expect(context.request.env["QUERY_STRING"]).to eq "/mock_request"
+      end
+    end
+
+    context "context class defined" do
+      def before_prepare
+        super()
+
+        write "app/views/context.rb", <<~RUBY
+          # auto_register: false
+
+          module TestApp
+            module Views
+              class Context < Hanami::View::Context
+                def concrete_app_context?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "uses the defined context class" do
+        expect(context).to be_an_instance_of TestApp::Views::Context
+        expect(context).to be_a_concrete_app_context
+      end
+    end
+
+    context "hanami-view not bundled" do
+      before do
+        allow(Hanami).to receive(:bundled?).and_call_original
+        expect(Hanami).to receive(:bundled?).with("hanami-view").and_return false
+      end
+
+      it "does not provide a context" do
+        expect(context).to be nil
+      end
+
+      context "context class defined" do
+        def before_prepare
+          super()
+
+          write "app/views/context.rb", <<~RUBY
+            module TestApp
+              module Views
+                class Context
+                  def initialize(**)
+                  end
+
+                  def with(**)
+                    self
+                  end
+
+                  def concrete_app_context?
+                    true
+                  end
+                end
+              end
+            end
+          RUBY
+        end
+
+        it "uses the defined context class" do
+          expect(context).to be_an_instance_of TestApp::Views::Context
+          expect(context).to be_a_concrete_app_context
+        end
+      end
+    end
+  end
+
+  describe "slice action" do
+    let(:action) { Main::Slice["actions.posts.show"] }
+
+    def before_prepare
+      write "slices/main/action.rb", <<~RUBY
+        module Main
+          class Action < TestApp::Action
+          end
+        end
+      RUBY
+
+      write "slices/main/actions/posts/show.rb", <<~RUBY
+        module Main
+          module Actions
+            module Posts
+              class Show < Main::Action
+              end
+            end
+          end
+        end
+      RUBY
+
+      # Custom view class as a spy for `#call` args
+      write "slices/main/views/posts/show.rb", <<~RUBY
+        module Main
+          module Views
+            module Posts
+              class Show
+                attr_reader :called_with
+
+                def call(**args)
+                  @called_with = args
+                  ""
+                end
+              end
+            end
+          end
+        end
+      RUBY
+    end
+
+    context "no context class defined" do
+      it "defines and uses a context class" do
+        expect(context).to be_an_instance_of Main::Views::Context
+        expect(context.class).to be < Hanami::View::Context
+      end
+    end
+
+    context "context class defined" do
+      def before_prepare
+        super()
+
+        write "slices/main/views/context.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            module Views
+              class Context < Hanami::View::Context
+                def concrete_slice_context?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "uses the defined context class" do
+        expect(context).to be_an_instance_of Main::Views::Context
+        expect(context).to be_a_concrete_slice_context
+      end
+    end
+  end
+end

data/spec/integration/action/view_rendering_spec.rb

@@ -32,24 +32,6 @@ RSpec.describe "App action / View rendering", :app_integration do
         end
       RUBY
 
-      write "app/views/context.rb", <<~RUBY
-        require "hanami/view/context"
-
-        module TestApp
-          module Views
-            class Context < Hanami::View::Context
-              def request
-                _options.fetch(:request)
-              end
-
-              def response
-                _options.fetch(:response)
-              end
-            end
-          end
-        end
-      RUBY
-
       write "app/actions/users/show.rb", <<~RUBY
         module TestApp
           module Actions

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
@@ -316,8 +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 404
-      expect(last_response.body).to eq "Not Found"
+      expect(last_response.status).to eq 500
       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 500
+        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 500
+      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 500
+        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

@@ -210,10 +210,11 @@ RSpec.describe "Hanami web app", :app_integration 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"] = "test"
+      ENV["HANAMI_ENV"] = @prev_hanami_env
     end
 
     specify "Has rack monitor preconfigured with default request logging (when used via a slice)" do
@@ -569,6 +570,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 +602,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/view/config/default_context_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+RSpec.describe "App view / Config / Default context", :app_integration do
+  before do
+    with_directory(@dir = make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+          end
+        end
+      RUBY
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  subject(:default_context) { view_class.config.default_context }
+
+  describe "app view" do
+    let(:view_class) { TestApp::View }
+
+    describe "no concrete context class defined" do
+      it "generates an app context class and configures it as the view's default_context" do
+        expect(default_context).to be_an_instance_of TestApp::Views::Context
+        expect(default_context.class.superclass).to be Hanami::View::Context
+      end
+    end
+
+    describe "concrete context class defined" do
+      def before_prepare
+        write "app/views/context.rb", <<~RUBY
+          # auto_register: false
+
+          module TestApp
+            module Views
+              class Context < Hanami::View::Context
+                def concrete?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "configures the app scope class as the view's scope_class" do
+        expect(default_context).to be_an_instance_of TestApp::Views::Context
+        expect(default_context).to be_concrete
+      end
+    end
+  end
+
+  describe "slice view" do
+    let(:view_class) { Main::View }
+
+    def before_prepare
+      write "slices/main/view.rb", <<~RUBY
+        # auto_register: false
+
+        module Main
+          class View < TestApp::View
+          end
+        end
+      RUBY
+    end
+
+    describe "no concrete slice context class defined" do
+      it "generates an app context class and configures it as the view's default_context" do
+        expect(default_context).to be_an_instance_of Main::Views::Context
+        expect(default_context.class.superclass).to be TestApp::Views::Context
+      end
+    end
+
+    describe "concrete slice context class defined" do
+      def before_prepare
+        super
+
+        write "slices/main/views/context.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            module Views
+              class Context < Hanami::View::Context
+                def concrete?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "configures the slice context as the view's default_context" do
+        expect(default_context).to be_an_instance_of Main::Views::Context
+        expect(default_context).to be_concrete
+      end
+    end
+
+    describe "view not inheriting from app view, no concrete context class defined" do
+      def before_prepare
+        write "slices/main/view.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            class View < Hanami::View
+            end
+          end
+        RUBY
+      end
+
+      it "generates a slice context class, inheriting from the app context class, and configures it as the view's default_context" do
+        expect(default_context).to be_an_instance_of Main::Views::Context
+        expect(default_context.class.superclass).to be TestApp::Views::Context
+      end
+    end
+
+    describe "no app view class defined" do
+      def before_prepare
+        FileUtils.rm "app/view.rb"
+
+        write "slices/main/view.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            class View < Hanami::View
+            end
+          end
+        RUBY
+      end
+
+      it "generates a slice context class, inheriting from the app context class, and configures it as the view's default_context" do
+        expect(default_context).to be_an_instance_of Main::Views::Context
+        expect(default_context.class.superclass).to be Hanami::View::Context
+      end
+    end
+  end
+end

data/spec/integration/view/{inflector_spec.rb → config/inflector_spec.rb}

@@ -2,7 +2,7 @@
 
 require "hanami"
 
-RSpec.describe "App view / Inflector", :app_integration do
+RSpec.describe "App view / Config / Inflector", :app_integration do
   before do
     module TestApp
       class App < Hanami::App

data/spec/integration/view/config/part_class_spec.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+RSpec.describe "App view / Config / Part class", :app_integration do
+  before do
+    with_directory(make_tmp_directory) do
+      write "config/app.rb", <<~RUBY
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+          end
+        end
+      RUBY
+
+      before_prepare if respond_to?(:before_prepare)
+      require "hanami/prepare"
+    end
+  end
+
+  describe "app view" do
+    let(:view_class) { TestApp::View }
+
+    context "no concrete app part class defined" do
+      it "generates an app part class and configures it as the view's part_class" do
+        expect(view_class.config.part_class).to be TestApp::Views::Part
+        expect(view_class.config.part_class.superclass).to be Hanami::View::Part
+      end
+    end
+
+    context "concrete app part class defined" do
+      def before_prepare
+        write "app/views/part.rb", <<~RUBY
+          # auto_register: false
+
+          module TestApp
+            module Views
+              class Part < Hanami::View::Part
+                def self.concrete?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "configures the app part class as the view's part_class" do
+        expect(view_class.config.part_class).to be TestApp::Views::Part
+        expect(view_class.config.part_class).to be_concrete
+      end
+    end
+  end
+
+  describe "slice view" do
+    let(:view_class) { Main::View }
+
+    def before_prepare
+      write "slices/main/view.rb", <<~RUBY
+        # auto_register: false
+
+        module Main
+          class View < TestApp::View
+          end
+        end
+      RUBY
+    end
+
+    context "no concrete slice part class defined" do
+      it "generates a slice part class, inheriting from the app part class, and configures it as the view's part_class" do
+        expect(view_class.config.part_class).to be Main::Views::Part
+        expect(view_class.config.part_class.superclass).to be TestApp::Views::Part
+      end
+    end
+
+    context "concrete slice part class defined" do
+      def before_prepare
+        super
+
+        write "slices/main/views/part.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            module Views
+              class Part < TestApp::Views::Part
+                def self.concrete?
+                  true
+                end
+              end
+            end
+          end
+        RUBY
+      end
+
+      it "configures the slice part class as the view's part_class" do
+        expect(view_class.config.part_class).to be Main::Views::Part
+        expect(view_class.config.part_class).to be_concrete
+      end
+    end
+
+    context "view not inheriting from app view, no concrete part class" do
+      def before_prepare
+        write "slices/main/view.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            class View < Hanami::View
+            end
+          end
+        RUBY
+      end
+
+      it "generates a slice part class, inheriting from the app part class, and configures it as the view's part_class" do
+        expect(view_class.config.part_class).to be Main::Views::Part
+        expect(view_class.config.part_class.superclass).to be TestApp::Views::Part
+      end
+    end
+
+    context "no app view class defined" do
+      def before_prepare
+        FileUtils.rm "app/view.rb"
+
+        write "slices/main/view.rb", <<~RUBY
+          # auto_register: false
+
+          module Main
+            class View < Hanami::View
+            end
+          end
+        RUBY
+      end
+
+      it "generates a slice part class, inheriting from Hanami::View::Part, and configures it as the view's part_class" do
+        expect(view_class.config.part_class).to be Main::Views::Part
+        expect(view_class.config.part_class.superclass).to be Hanami::View::Part
+      end
+    end
+  end
+end