hanami 2.3.0.beta1 → 2.3.0

data/spec/integration/action/slice_configuration_spec.rb

@@ -34,25 +34,25 @@ RSpec.describe "App action / Slice configuration", :app_integration do
       it "applies default actions config from the app", :aggregate_failures do
         prepare_app
 
-        expect(TestApp::Action.config.formats.values).to eq []
+        expect(TestApp::Action.config.formats.accepted).to eq []
       end
 
       it "applies actions config from the app" do
-        Hanami.app.config.actions.format :json
+        Hanami.app.config.actions.formats.accepted = [:json]
 
         prepare_app
 
-        expect(TestApp::Action.config.formats.values).to eq [:json]
+        expect(TestApp::Action.config.formats.accepted).to eq [:json]
       end
 
       it "does not override config in the base class" do
-        Hanami.app.config.actions.format :csv
+        Hanami.app.config.actions.formats.accepted = [:csv]
 
         prepare_app
 
-        TestApp::Action.config.format :json
+        TestApp::Action.config.formats.accepted = [:json]
 
-        expect(TestApp::Action.config.formats.values).to eq [:json]
+        expect(TestApp::Action.config.formats.accepted).to eq [:json]
       end
     end
 
@@ -75,23 +75,23 @@ RSpec.describe "App action / Slice configuration", :app_integration do
       it "applies default actions config from the app", :aggregate_failures do
         prepare_app
 
-        expect(TestApp::Actions::Articles::Index.config.formats.values).to eq []
+        expect(TestApp::Actions::Articles::Index.config.formats.accepted).to eq []
       end
 
       it "applies actions config from the app" do
-        Hanami.app.config.actions.format :json
+        Hanami.app.config.actions.formats.accepted = [:json]
 
         prepare_app
 
-        expect(TestApp::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(TestApp::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
 
       it "applies config from the base class" do
         prepare_app
 
-        TestApp::Action.config.format :json
+        TestApp::Action.config.formats.accepted = [:json]
 
-        expect(TestApp::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(TestApp::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
     end
 
@@ -114,23 +114,23 @@ RSpec.describe "App action / Slice configuration", :app_integration do
       it "applies default actions config from the app", :aggregate_failures do
         prepare_app
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq []
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq []
       end
 
       it "applies actions config from the app" do
-        Hanami.app.config.actions.format :json
+        Hanami.app.config.actions.formats.accepted = [:json]
 
         prepare_app
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
 
       it "applies config from the base class" do
         prepare_app
 
-        TestApp::Action.config.format :json
+        TestApp::Action.config.formats.accepted = [:json]
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
     end
   end
@@ -151,23 +151,23 @@ RSpec.describe "App action / Slice configuration", :app_integration do
       it "applies default actions config from the app", :aggregate_failures do
         prepare_app
 
-        expect(Admin::Action.config.formats.values).to eq []
+        expect(Admin::Action.config.formats.accepted).to eq []
       end
 
       it "applies actions config from the app" do
-        Hanami.app.config.actions.format :json
+        Hanami.app.config.actions.formats.accepted = [:json]
 
         prepare_app
 
-        expect(Admin::Action.config.formats.values).to eq [:json]
+        expect(Admin::Action.config.formats.accepted).to eq [:json]
       end
 
       it "applies config from the app base class" do
         prepare_app
 
-        TestApp::Action.config.format :json
+        TestApp::Action.config.formats.accepted = [:json]
 
-        expect(Admin::Action.config.formats.values).to eq [:json]
+        expect(Admin::Action.config.formats.accepted).to eq [:json]
       end
 
       context "slice actions config present" do
@@ -186,24 +186,24 @@ RSpec.describe "App action / Slice configuration", :app_integration do
         it "applies actions config from the slice" do
           prepare_app
 
-          expect(Admin::Action.config.formats.values).to eq [:csv]
+          expect(Admin::Action.config.formats.accepted).to eq [:csv]
         end
 
         it "prefers actions config from the slice over config from the app-level base class" do
           prepare_app
 
-          TestApp::Action.config.format :json
+          TestApp::Action.config.formats.accepted = [:json]
 
-          expect(Admin::Action.config.formats.values).to eq [:csv]
+          expect(Admin::Action.config.formats.accepted).to eq [:csv]
         end
 
         it "prefers config from the base class over actions config from the slice" do
           prepare_app
 
-          TestApp::Action.config.format :csv
-          Admin::Action.config.format :json
+          TestApp::Action.config.formats.accepted = [:csv]
+          Admin::Action.config.formats.accepted = [:json]
 
-          expect(Admin::Action.config.formats.values).to eq [:json]
+          expect(Admin::Action.config.formats.accepted).to eq [:json]
         end
       end
     end
@@ -227,15 +227,15 @@ RSpec.describe "App action / Slice configuration", :app_integration do
       it "applies default actions config from the app", :aggregate_failures do
         prepare_app
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq []
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq []
       end
 
       it "applies actions config from the app" do
-        Hanami.app.config.actions.format :json
+        Hanami.app.config.actions.formats.accepted = [:json]
 
         prepare_app
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
 
       it "applies actions config from the slice" do
@@ -243,7 +243,7 @@ RSpec.describe "App action / Slice configuration", :app_integration do
           write "config/slices/admin.rb", <<~'RUBY'
             module Admin
               class Slice < Hanami::Slice
-                config.actions.format :json
+                config.actions.formats.accepted = [:json]
               end
             end
           RUBY
@@ -251,15 +251,15 @@ RSpec.describe "App action / Slice configuration", :app_integration do
 
         prepare_app
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
 
       it "applies config from the slice base class" do
         prepare_app
 
-        Admin::Action.config.format :json
+        Admin::Action.config.formats.accepted = [:json]
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
 
       it "prefers config from the slice base class over actions config from the slice" do
@@ -275,9 +275,9 @@ RSpec.describe "App action / Slice configuration", :app_integration do
 
         prepare_app
 
-        Admin::Action.config.format :json
+        Admin::Action.config.formats.accepted = [:json]
 
-        expect(Admin::Actions::Articles::Index.config.formats.values).to eq [:json]
+        expect(Admin::Actions::Articles::Index.config.formats.accepted).to eq [:json]
       end
     end
   end

data/spec/integration/logging/request_logging_spec.rb

@@ -11,10 +11,13 @@ RSpec.describe "Logging / Request logging", :app_integration do
 
   let(:logger_stream) { StringIO.new }
 
+  let(:logger_level) { nil }
+
   let(:root) { make_tmp_directory }
 
   def configure_logger
     Hanami.app.config.logger.stream = logger_stream
+    Hanami.app.config.logger.level = logger_level if logger_level
   end
 
   def logs
@@ -84,6 +87,19 @@ RSpec.describe "Logging / Request logging", :app_integration do
         )
       end
     end
+
+    context "log level error" do
+      let(:logger_level) { :error }
+      before do
+        expect_any_instance_of(Hanami::Web::RackLogger).to_not receive(:data)
+      end
+
+      it "does not log info" do
+        get "/"
+
+        expect(logs.split("\n").length).to eq 0
+      end
+    end
   end
 
   describe "slice router" do

data/spec/integration/operations/extension_spec.rb

@@ -56,4 +56,67 @@ RSpec.describe "Operation / Extensions", :app_integration do
       expect(main.rom).to be Main::Slice["db.rom"]
     end
   end
+
+  context "hanami-db bundled, but no db configured" do
+    it "does not extend the operation class" do
+      with_tmp_directory(Dir.mktmpdir) do
+        write "config/app.rb", <<~RUBY
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "app/operation.rb", <<~RUBY
+          module TestApp
+            class Operation < Dry::Operation
+            end
+          end
+        RUBY
+
+        require "hanami/prepare"
+
+        operation = TestApp::Operation.new
+
+        expect(operation.rom).to be nil
+        expect { operation.transaction }.to raise_error Hanami::ComponentLoadError, "A configured db for TestApp::App is required to run transactions."
+      end
+    end
+  end
+
+  context "hanami-db not bundled" do
+    before do
+      allow(Hanami).to receive(:bundled?).and_call_original
+      allow(Hanami).to receive(:bundled?).with("hanami-db").and_return false
+    end
+
+    it "does not extend the operation class" do
+      with_tmp_directory(Dir.mktmpdir) do
+        write "config/app.rb", <<~RUBY
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "app/operation.rb", <<~RUBY
+          module TestApp
+            class Operation < Dry::Operation
+            end
+          end
+        RUBY
+
+        require "hanami/prepare"
+
+        operation = TestApp::Operation.new
+
+        expect { operation.rom }.to raise_error NoMethodError
+        expect { operation.transaction }.to raise_error NoMethodError
+      end
+    end
+  end
 end

data/spec/integration/rack_app/body_parser_spec.rb

@@ -12,14 +12,13 @@ RSpec.describe "Hanami web app", :app_integration do
     with_tmp_directory(Dir.mktmpdir, &example)
   end
 
-  specify "Setting middlewares in the config" do
+  specify "Default body parser" do
     write "config/app.rb", <<~RUBY
       require "hanami"
 
       module TestApp
         class App < Hanami::App
           config.actions.format :json
-          config.middleware.use :body_parser, :json
           config.logger.stream = StringIO.new
         end
       end
@@ -65,7 +64,8 @@ RSpec.describe "Hanami web app", :app_integration do
 
       module TestApp
         class App < Hanami::App
-          config.actions.formats.add :json, ["application/json+scim"]
+          config.actions.formats.register :json, "application/json+scim"
+          config.actions.formats.accept :json
           config.middleware.use :body_parser, [json: "application/json+scim"]
           config.logger.stream = StringIO.new
         end

data/spec/integration/rack_app/rack_app_spec.rb

@@ -305,7 +305,7 @@ RSpec.describe "Hanami web app", :app_integration do
       expect { Hanami.app.rack_app }.to raise_error do |exception|
         expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
         expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in TestApp::App")
-        expect(exception.message).to match(%r{define the action class TestApp::Actions::Missing::Action.+actions/missing/action.rb})
+        expect(exception.message).to include("define the action class TestApp::Actions::Missing::Action in app/actions/missing/action.rb")
       end
     end
   end
@@ -337,7 +337,7 @@ RSpec.describe "Hanami web app", :app_integration do
       expect { Hanami.app.rack_app }.to raise_error do |exception|
         expect(exception).to be_kind_of(Hanami::Routes::MissingActionError)
         expect(exception.message).to include("Could not find action with key \"actions.missing.action\" in Admin::Slice")
-        expect(exception.message).to match(%r{define the action class Admin::Actions::Missing::Action.+slices/admin/actions/missing/action.rb})
+        expect(exception.message).to include("define the action class Admin::Actions::Missing::Action in slices/admin/actions/missing/action.rb")
       end
     end
   end

data/spec/integration/router/resource_routes_spec.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require "dry/inflector"
+require "hanami/slice/router"
+require "json"
+
+RSpec.describe "Router / Resource routes" do
+  let(:router) { Hanami::Slice::Router.new(routes:, resolver:, inflector: Dry::Inflector.new) { } }
+
+  let(:resolver) { Hanami::Slice::Routing::Resolver.new(slice:) }
+  let(:slice) {
+    Class.new(Hanami::Slice).tap { |slice|
+      allow(slice).to receive(:container) { actions_container }
+      allow(slice).to receive(:slices) { {reviews: child_slice} }
+    }
+  }
+  let(:child_slice) {
+    Class.new(Hanami::Slice).tap { |slice|
+      allow(slice).to receive(:container) { actions_container("[reviews]") }
+    }
+  }
+  def actions_container(prefix = nil)
+    Hash.new { |_hsh, key|
+      Class.new { |klass|
+        klass.define_method(:call) do |env|
+          body = key
+          body = "#{body} #{JSON.generate(env["router.params"])}" if env["router.params"].any?
+          body = "#{prefix}#{body}" if prefix
+          [200, {}, body]
+        end
+      }.new
+    }.tap { |container|
+      def container.resolve(key) = self[key]
+    }
+  end
+
+  let(:app) { Rack::MockRequest.new(router) }
+  def routed(method, url)
+    app.request(method, url).body
+  end
+
+  describe "resources" do
+    let(:routes) { proc { resources :posts } }
+
+    it "routes all RESTful actions to the resource" do
+      expect(routed("GET", "/posts")).to eq %(actions.posts.index)
+      expect(routed("GET", "/posts/new")).to eq %(actions.posts.new)
+      expect(routed("POST", "/posts")).to eq %(actions.posts.create)
+      expect(routed("GET", "/posts/1")).to eq %(actions.posts.show {"id":"1"})
+      expect(routed("GET", "/posts/1/edit")).to eq %(actions.posts.edit {"id":"1"})
+      expect(routed("PATCH", "/posts/1")).to eq %(actions.posts.update {"id":"1"})
+      expect(routed("DELETE", "/posts/1")).to eq %(actions.posts.destroy {"id":"1"})
+
+      expect(router.path("posts")).to eq "/posts"
+      expect(router.path("new_post")).to eq "/posts/new"
+      expect(router.path("edit_post", id: 1)).to eq "/posts/1/edit"
+    end
+
+    describe "with :only" do
+      let(:routes) { proc { resources :posts, only: %i(index show) } }
+
+      it "routes only the given actions to the resource" do
+        expect(routed("GET", "/posts")).to eq %(actions.posts.index)
+        expect(routed("GET", "/posts/1")).to eq %(actions.posts.show {"id":"1"})
+
+        expect(routed("GET", "/posts/new")).not_to eq %(actions.posts.new)
+        expect(routed("POST", "/posts")).to eq "Method Not Allowed"
+        expect(routed("GET", "/posts/1/edit")).to eq "Not Found"
+        expect(routed("PATCH", "/posts/1")).to eq "Method Not Allowed"
+        expect(routed("DELETE", "/posts/1")).to eq "Method Not Allowed"
+      end
+    end
+
+    describe "with :except" do
+      let(:routes) { proc { resources :posts, except: %i(edit update destroy) } }
+
+      it "routes all except the given actions to the resource" do
+        expect(routed("GET", "/posts")).to eq %(actions.posts.index)
+        expect(routed("GET", "/posts/new")).to eq %(actions.posts.new)
+        expect(routed("POST", "/posts")).to eq %(actions.posts.create)
+        expect(routed("GET", "/posts/1")).to eq %(actions.posts.show {"id":"1"})
+
+        expect(routed("GET", "/posts/1/edit")).to eq "Not Found"
+        expect(routed("PATCH", "/posts/1")).to eq "Method Not Allowed"
+        expect(routed("DELETE", "/posts/1")).to eq "Method Not Allowed"
+      end
+    end
+
+    describe "with :to" do
+      let(:routes) { proc { resources :posts, to: "articles" } }
+
+      it "uses actions from the given container key namespace" do
+        expect(routed("GET", "/posts")).to eq %(actions.articles.index)
+        expect(routed("GET", "/posts/new")).to eq %(actions.articles.new)
+        expect(routed("POST", "/posts")).to eq %(actions.articles.create)
+        expect(routed("GET", "/posts/1")).to eq %(actions.articles.show {"id":"1"})
+        expect(routed("GET", "/posts/1/edit")).to eq %(actions.articles.edit {"id":"1"})
+        expect(routed("PATCH", "/posts/1")).to eq %(actions.articles.update {"id":"1"})
+        expect(routed("DELETE", "/posts/1")).to eq %(actions.articles.destroy {"id":"1"})
+      end
+    end
+
+    describe "witih :path" do
+      let(:routes) { proc { resources :posts, path: "articles" } }
+
+      it "uses the given path for the routes" do
+        expect(routed("GET", "/articles")).to eq %(actions.posts.index)
+        expect(routed("GET", "/articles/new")).to eq %(actions.posts.new)
+        expect(routed("POST", "/articles")).to eq %(actions.posts.create)
+        expect(routed("GET", "/articles/1")).to eq %(actions.posts.show {"id":"1"})
+        expect(routed("GET", "/articles/1/edit")).to eq %(actions.posts.edit {"id":"1"})
+        expect(routed("PATCH", "/articles/1")).to eq %(actions.posts.update {"id":"1"})
+        expect(routed("DELETE", "/articles/1")).to eq %(actions.posts.destroy {"id":"1"})
+      end
+    end
+  end
+
+  describe "resource" do
+    let(:routes) { proc { resource :profile } }
+
+    it "routes all RESTful actions (except index) to the resource" do
+      expect(routed("GET", "/profile/new")).to eq %(actions.profile.new)
+      expect(routed("POST", "/profile")).to eq %(actions.profile.create)
+      expect(routed("GET", "/profile")).to eq %(actions.profile.show)
+      expect(routed("GET", "/profile/edit")).to eq %(actions.profile.edit)
+      expect(routed("PATCH", "/profile")).to eq %(actions.profile.update)
+      expect(routed("DELETE", "/profile")).to eq %(actions.profile.destroy)
+
+      expect(routed("GET", "/profiles")).to eq "Not Found"
+      expect(routed("GET", "/profiles/1")).to eq "Not Found"
+      expect(routed("GET", "/profile/1")).to eq "Not Found"
+
+      expect(router.path("profile")).to eq "/profile"
+      expect(router.path("new_profile")).to eq "/profile/new"
+      expect(router.path("edit_profile")).to eq "/profile/edit"
+    end
+
+    describe "with :only" do
+      let(:routes) { proc { resource :profile, only: %i(show edit update) } }
+
+      it "routes only the given actions to the resource" do
+        expect(routed("GET", "/profile")).to eq %(actions.profile.show)
+        expect(routed("GET", "/profile/edit")).to eq %(actions.profile.edit)
+        expect(routed("PATCH", "/profile")).to eq %(actions.profile.update)
+
+        expect(routed("GET", "/profile/new")).to eq "Not Found"
+        expect(routed("POST", "/profile")).to eq "Method Not Allowed"
+        expect(routed("DELETE", "/profile")).to eq "Method Not Allowed"
+      end
+    end
+
+    describe "with :except" do
+      let(:routes) { proc { resource :profile, except: %i(edit update destroy) } }
+
+      it "routes all except the given actions to the resource" do
+        expect(routed("GET", "/profile/new")).to eq %(actions.profile.new)
+        expect(routed("POST", "/profile")).to eq %(actions.profile.create)
+        expect(routed("GET", "/profile")).to eq %(actions.profile.show)
+
+        expect(routed("GET", "/profile/edit")).to eq "Not Found"
+        expect(routed("PATCH", "/profile")).to eq "Method Not Allowed"
+        expect(routed("DELETE", "/profile")).to eq "Method Not Allowed"
+      end
+    end
+
+    describe "with :to" do
+      let(:routes) { proc { resource :profile, to: "user" } }
+
+      it "uses actions from the given container key namespace" do
+        expect(routed("GET", "/profile/new")).to eq %(actions.user.new)
+        expect(routed("POST", "/profile")).to eq %(actions.user.create)
+        expect(routed("GET", "/profile")).to eq %(actions.user.show)
+        expect(routed("GET", "/profile/edit")).to eq %(actions.user.edit)
+        expect(routed("PATCH", "/profile")).to eq %(actions.user.update)
+        expect(routed("DELETE", "/profile")).to eq %(actions.user.destroy)
+      end
+    end
+
+    describe "with :path" do
+      let(:routes) { proc { resource :profile, path: "user"} }
+
+      it "uses the given path for the routes" do
+        expect(routed("GET", "/user/new")).to eq %(actions.profile.new)
+        expect(routed("POST", "/user")).to eq %(actions.profile.create)
+        expect(routed("GET", "/user")).to eq %(actions.profile.show)
+        expect(routed("GET", "/user/edit")).to eq %(actions.profile.edit)
+        expect(routed("PATCH", "/user")).to eq %(actions.profile.update)
+        expect(routed("DELETE", "/user")).to eq %(actions.profile.destroy)
+      end
+    end
+  end
+
+  describe "nested resources" do
+    let(:routes) {
+      proc {
+        resources :cafes, only: :show do
+          resources :reviews, only: :index do
+            resources :comments, only: [:index, :new, :create]
+          end
+        end
+
+        resource :profile, only: :show do
+          resource :avatar, only: :show do
+            resources :comments, only: :index
+          end
+        end
+      }
+    }
+
+    it "routes to the nested resources" do
+      expect(routed("GET", "/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
+      expect(routed("GET", "/cafes/1/reviews")).to eq %(actions.cafes.reviews.index {"cafe_id":"1"})
+      expect(routed("GET", "/cafes/1/reviews/2/comments")).to eq %(actions.cafes.reviews.comments.index {"cafe_id":"1","review_id":"2"})
+
+      expect(router.path("cafe", id: 1)).to eq "/cafes/1"
+      expect(router.path("cafe_reviews", cafe_id: 1)).to eq "/cafes/1/reviews"
+      expect(router.path("cafe_review_comments", cafe_id: 1, review_id: 1)).to eq "/cafes/1/reviews/1/comments"
+      expect(router.path("new_cafe_review_comment", cafe_id: 1, review_id: 1)).to eq "/cafes/1/reviews/1/comments/new"
+
+      expect(routed("GET", "/profile")).to eq %(actions.profile.show)
+      expect(routed("GET", "/profile/avatar")).to eq %(actions.profile.avatar.show)
+      expect(routed("GET", "/profile/avatar/comments")).to eq %(actions.profile.avatar.comments.index)
+    end
+  end
+
+  describe "standalone routes nested under resources" do
+    let(:routes) {
+      proc {
+        resources :cafes, only: :show do
+          get "/top-reviews", to: "cafes.top_reviews.index", as: :top_reviews
+        end
+      }
+    }
+
+    it "nests the standalone route under the resource" do
+      expect(routed("GET", "/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
+      expect(routed("GET", "/cafes/1/top-reviews")).to eq %(actions.cafes.top_reviews.index {"cafe_id":"1"})
+
+      expect(router.path("cafe_top_reviews", cafe_id: 1)).to eq "/cafes/1/top-reviews"
+    end
+  end
+
+  describe "resources nested under scopes" do
+    let(:routes) {
+      proc {
+        scope "coffee-lovers" do
+          resources :cafes, only: :show do
+            get "/top-reviews", to: "cafes.top_reviews.index", as: :top_reviews
+          end
+        end
+      }
+    }
+
+    it "routes to the resources under the scope" do
+      expect(routed("GET", "/coffee-lovers/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
+      expect(routed("GET", "/coffee-lovers/cafes/1/top-reviews")).to eq %(actions.cafes.top_reviews.index {"cafe_id":"1"})
+
+      expect(router.path("coffee_lovers_cafe", id: 1)).to eq "/coffee-lovers/cafes/1"
+      expect(router.path("coffee_lovers_cafe_top_reviews", cafe_id: 1)).to eq "/coffee-lovers/cafes/1/top-reviews"
+    end
+  end
+
+  describe "slices nested under resources" do
+    let(:routes) {
+      proc {
+        resources :cafes, only: :show do
+          slice :reviews, at: "" do
+            resources :reviews, only: :index
+          end
+        end
+      }
+    }
+
+    it "routes to actions within the nested slice" do
+      expect(routed("GET", "/cafes/1")).to eq %(actions.cafes.show {"id":"1"})
+      expect(routed("GET", "/cafes/1/reviews")).to eq %([reviews]actions.cafes.reviews.index {"cafe_id":"1"})
+
+      expect(router.path("cafe_reviews", cafe_id: 1)).to eq "/cafes/1/reviews"
+    end
+  end
+end

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

@@ -23,9 +23,9 @@ RSpec.describe Hanami::Config, "#actions" do
     end
 
     it "configures base actions settings using custom methods" do
-      expect { actions.formats.add(:json, "app/json") }
+      expect { actions.formats.register(:json, "app/json") }
         .to change { actions.formats.mapping }
-        .to include("app/json" => :json)
+        .to include(json: have_attributes(media_type: "app/json"))
     end
 
     it "can be finalized" do