hanami 2.0.0.alpha7.1 → 2.0.0.beta1.1

data/spec/new_integration/action/routes_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+RSpec.describe "App action / Routes", :app_integration do
+  specify "Access app routes from an action" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App; end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~RUBY
+        module TestApp
+          class Routes < Hanami::Routes
+            define do
+              root to: "home.index"
+
+              slice :admin, at: "/admin" do
+                root to: "dashboard.index"
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/action.rb", <<~RUBY
+        # auto_register: false
+
+        module TestApp
+          class Action < Hanami::Action; end
+        end
+      RUBY
+
+      write "app/actions/home/index.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Home
+              class Index < TestApp::Action
+                def handle(req, res)
+                  res.body = routes.path(:root)
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "slices/admin/actions/dashboard/index.rb", <<~RUBY
+        module Admin
+          module Actions
+            module Dashboard
+              class Index < TestApp::Action
+                def handle(req, res)
+                  res.body = routes.path(:admin_root)
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      response = TestApp::App["actions.home.index"].call({})
+      expect(response.body).to eq ["/"]
+
+      response = Admin::Slice["actions.dashboard.index"].call({})
+      expect(response.body).to eq ["/admin"]
+    end
+  end
+end

data/spec/new_integration/action/sessions_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe "App action / Sessions", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.prepare
+
+    module TestApp
+      class Action < Hanami::Action
+      end
+    end
+  end
+
+  subject(:action_class) { TestApp::Action }
+
+  context "HTTP sessions enabled" do
+    let(:app_hook) {
+      proc do
+        config.actions.sessions = :cookie, {secret: "abc123"}
+      end
+    }
+
+    it "has HTTP sessions enabled" do
+      expect(action_class.ancestors).to include(Hanami::Action::Session)
+    end
+  end
+
+  context "HTTP sessions explicitly disabled" do
+    let(:app_hook) {
+      proc do
+        config.actions.sessions = nil
+      end
+    }
+
+    it "does not have HTTP sessions enabled" do
+      expect(action_class.ancestors.map(&:to_s)).not_to include("Hanami::Action::Session")
+    end
+  end
+
+  context "HTTP sessions not enabled" do
+    it "does not have HTTP session enabled" do
+      expect(action_class.ancestors.map(&:to_s)).not_to include("Hanami::Action::Session")
+    end
+  end
+end

data/spec/new_integration/action/view_integration_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe "App action / View integration", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.prepare
+
+    module TestApp
+      class Action < Hanami::Action; end
+    end
+
+    module TestApp
+      module Actions
+        module Articles
+          class Index < TestApp::Action; end
+        end
+      end
+    end
+  end
+
+  let(:action_class) { TestApp::Actions::Articles::Index }
+  subject(:action) { action_class.new(**action_args) }
+  let(:action_args) { {} }
+
+  describe "#view_context" do
+    subject(:view_context) { action.view_context }
+
+    context "Explicitly injected view context" do
+      let(:view_context) { double(:view_context) }
+      let(:action_args) { {view_context: view_context} }
+
+      it "returns the injected object" do
+        is_expected.to eql view_context
+      end
+    end
+
+    context "No view context registered" do
+      it "is nil" do
+        is_expected.to be_nil
+      end
+    end
+
+    context "Default view context identifier" do
+      context "View context registered in slice" do
+        before do
+          TestApp::App.register "views.context", slice_view_context
+        end
+
+        let(:slice_view_context) { double(:slice_view_context) }
+
+        it "is the slice's view context" do
+          is_expected.to eql slice_view_context
+        end
+      end
+
+      context "View context registered in app" do
+        before do
+          Hanami.app.register "views.context", app_view_context
+        end
+
+        let(:app_view_context) { double(:app_view_context) }
+
+        it "is the apps's view context" do
+          is_expected.to eql app_view_context
+        end
+      end
+    end
+
+    context "custom view context identifier" do
+      let(:app_hook) {
+        proc do |app|
+          app.config.actions.view_context_identifier = "view.custom_context"
+        end
+      }
+
+      before do
+        TestApp::App.register "view.custom_context", custom_view_context
+      end
+
+      let(:custom_view_context) { double(:custom_view_context) }
+
+      it "is the context registered with the custom identifier" do
+        is_expected.to eql custom_view_context
+      end
+    end
+  end
+
+  describe "#view_options" do
+    subject(:view_options) { action.send(:view_options, req, res) }
+    let(:req) { double(:req) }
+    let(:res) { double(:res) }
+
+    context "without view context" do
+      it "is an empty hash" do
+        is_expected.to eq({})
+      end
+    end
+
+    context "with view context" do
+      let(:initial_view_context) { double(:initial_view_context) }
+      let(:action_args) { {view_context: initial_view_context} }
+
+      context "default #view_context_options" do
+        let(:request_view_context) { double(:request_view_context) }
+
+        before do
+          allow(initial_view_context).to receive(:with).with(
+            request: req,
+            response: res,
+          ) { request_view_context }
+        end
+
+        it "is the view context with the request and response provided" do
+          is_expected.to eq(context: request_view_context)
+        end
+      end
+
+      context "custom #view_context_options" do
+        let(:custom_view_context) { double(:custom_view_context)}
+
+        before do
+          action_class.class_eval do
+            def view_context_options(req, res)
+              {custom_option: "custom option"}
+            end
+          end
+
+          allow(initial_view_context).to receive(:with).with(
+            custom_option: "custom option"
+          ) { custom_view_context }
+        end
+
+        it "is the view context with the custom options provided" do
+          is_expected.to eq(context: custom_view_context)
+        end
+      end
+
+      context "specialized method (calling super) defined in action class" do
+        let(:request_view_context) { double(:request_view_context) }
+
+        before do
+          allow(initial_view_context).to receive(:with).with(
+            request: req,
+            response: res,
+          ) { request_view_context }
+
+          action_class.class_eval do
+            def view_options(req, res)
+              super.merge(extra_option: "extra option")
+            end
+          end
+        end
+
+        it "includes the options provided by the specialized method" do
+          is_expected.to eq(context: request_view_context, extra_option: "extra option")
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/action/view_rendering/automatic_rendering_spec.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+RSpec.describe "App action / View rendering / Automatic rendering", :app_integration do
+  it "Renders a view automatically, passing all params and exposures" do
+    within_app do
+      write "app/actions/profile/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Profile
+              class Show < TestApp::Action
+                def handle(req, res)
+                  res[:favorite_number] = 123
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/views/profile/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Profile
+              class Show < TestApp::View
+                expose :name, :favorite_number
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/templates/profile/show.html.slim", <<~'SLIM'
+        h1 Hello, #{name}. Your favorite number is #{favorite_number}, right?
+      SLIM
+
+      require "hanami/prepare"
+
+      action = TestApp::App["actions.profile.show"]
+      response = action.(name: "Jennifer")
+      rendered = response.body[0]
+
+      expect(rendered).to eq "<html><body><h1>Hello, Jennifer. Your favorite number is 123, right?</h1></body></html>"
+      expect(response.status).to eq 200
+    end
+  end
+
+  it "Does not render a view automatically when #render? returns false " do
+    within_app do
+      write "app/actions/profile/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Profile
+              class Show < TestApp::Action
+                def handle(req, res)
+                  res[:favorite_number] = 123
+                end
+
+                def auto_render?(_res)
+                  false
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/views/profile/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Profile
+              class Show < TestApp::View
+                expose :name, :favorite_number
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/templates/profile/show.html.slim", <<~'SLIM'
+        h1 Hello, #{name}. Your favorite number is #{favorite_number}, right?
+      SLIM
+
+      require "hanami/prepare"
+
+      action = TestApp::App["actions.profile.show"]
+      response = action.(name: "Jennifer")
+
+      expect(response.body).to eq []
+      expect(response.status).to eq 200
+    end
+  end
+
+  it "Doesn't render view automatically when body is already assigned" do
+    within_app do
+      write "app/actions/profile/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Profile
+              class Show < TestApp::Action
+                def handle(req, res)
+                  res.body = "200: Okay okay okay"
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/views/profile/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Profile
+              class Show < TestApp::View
+                expose :name, :favorite_number
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/templates/profile/show.html.slim", <<~'SLIM'
+        h1 Hello, #{name}. Your favorite number is #{favorite_number}, right?
+      SLIM
+
+      require "hanami/prepare"
+
+      action = TestApp::App["actions.profile.show"]
+      response = action.(name: "Jennifer")
+      rendered = response.body[0]
+
+      expect(rendered).to eq "200: Okay okay okay"
+      expect(response.status).to eq 200
+    end
+  end
+
+  it "Doesn't render view automatically when halt is called" do
+    within_app do
+      write "app/actions/profile/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Profile
+              class Show < TestApp::Action
+                def handle(req, res)
+                  halt 404
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      write "app/views/profile/show.rb", <<~RUBY
+        module TestApp
+          module Views
+            module Profile
+              class Show < TestApp::View
+                expose :name
+              end
+            end
+          end
+        end
+      RUBY
+
+      # This template will crash if not rendered with a valid `name` string. The absence
+      # of a crash here tells us that the view was never rendered.
+      write "app/templates/profile/show.html.slim", <<~'SLIM'
+        h1 Hello, #{name.to_str}!
+      SLIM
+
+      require "hanami/prepare"
+
+      # Call the action without a `name` param, thereby ensuring the view will raise an
+      # error if rendered
+      action = TestApp::App["actions.profile.show"]
+      response = action.({})
+      rendered = response.body[0]
+
+      aggregate_failures do
+        expect(rendered).to eq "Not Found"
+        expect(response.status).to eq 404
+      end
+    end
+  end
+
+  it "Does not render if no view is available" do
+    within_app do
+      write "app/actions/profile/show.rb", <<~RUBY
+        module TestApp
+          module Actions
+            module Profile
+              class Show < TestApp::Action
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      action = TestApp::App["actions.profile.show"]
+      response = action.({})
+      expect(response.body).to eq []
+      expect(response.status).to eq 200
+    end
+  end
+
+  def within_app
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "app/action.rb", <<~RUBY
+        # auto_register: false
+
+        module TestApp
+          class Action < Hanami::Action
+          end
+        end
+      RUBY
+
+      write "app/view.rb", <<~RUBY
+        # auto_register: false
+
+        require "hanami/view"
+
+        module TestApp
+          class View < Hanami::View
+          end
+        end
+      RUBY
+
+      write "app/templates/layouts/app.html.slim", <<~SLIM
+        html
+          body
+            == yield
+      SLIM
+
+      yield
+    end
+  end
+end

data/spec/new_integration/action/view_rendering/paired_view_inference_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App action / View rendering / Paired view inference", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+
+    Hanami.app.prepare
+
+    module TestApp
+      class Action < Hanami::Action
+      end
+    end
+  end
+
+  let(:action) { action_class.new }
+
+  describe "Ordinary action" do
+    before do
+      module TestApp
+        module Actions
+          module Articles
+            class Index < TestApp::Action
+            end
+          end
+        end
+      end
+    end
+
+    let(:action_class) { TestApp::Actions::Articles::Index }
+
+    context "Paired view exists" do
+      before do
+        TestApp::App.register "views.articles.index", view
+      end
+
+      let(:view) { double(:view) }
+
+      it "auto-injects a paired view from a matching container identifier" do
+        expect(action.view).to be view
+      end
+
+      context "Another view explicitly auto-injected" do
+        before do
+          module TestApp
+            module Actions
+              module Articles
+                class Index < TestApp::Action
+                  include Deps[view: "views.articles.custom"]
+                end
+              end
+            end
+          end
+
+          TestApp::App.register "views.articles.custom", explicit_view
+        end
+
+        let(:action_class) { TestApp::Actions::Articles::Index }
+        let(:explicit_view) { double(:explicit_view) }
+
+        it "respects the explicitly auto-injected view" do
+          expect(action.view).to be explicit_view
+        end
+      end
+    end
+
+    context "No paired view exists" do
+      it "does not auto-inject any view" do
+        expect(action.view).to be_nil
+      end
+    end
+  end
+
+  describe "RESTful action" do
+    before do
+      module TestApp
+        module Actions
+          module Articles
+            class Create < TestApp::Action
+            end
+          end
+        end
+      end
+    end
+
+    let(:action_class) { TestApp::Actions::Articles::Create }
+    let(:direct_paired_view) { double(:direct_paired_view) }
+    let(:alternative_paired_view) { double(:alternative_paired_view) }
+
+    context "Direct paired view exists" do
+      before do
+        TestApp::App.register "views.articles.create", direct_paired_view
+        TestApp::App.register "views.articles.new", alternative_paired_view
+      end
+
+      it "auto-injects the directly paired view" do
+        expect(action.view).to be direct_paired_view
+      end
+    end
+
+    context "Alternative paired view exists" do
+      before do
+        TestApp::App.register "views.articles.new", alternative_paired_view
+      end
+
+      it "auto-injects the alternative paired view" do
+        expect(action.view).to be alternative_paired_view
+      end
+    end
+  end
+end