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

data/spec/new_integration/slices/external_slice_spec.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Slices / External slices", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { TestApp::App.app }
+
+  specify "External slices can be registered and used" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~'RUBY'
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+
+            require "external/slice"
+            register_slice(:external, External::Slice)
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~'RUBY'
+        require "hanami/routes"
+
+        module TestApp
+          class Routes < Hanami::Routes
+            define do
+              slice :external, at: "/" do
+                root to: "test_action"
+              end
+            end
+          end
+        end
+      RUBY
+
+      # Put a slice and its components in `lib/external/`, as if it were an external gem
+
+      write "lib/external/slice.rb", <<~'RUBY'
+        # auto_register: false
+
+        require "hanami/slice"
+
+        module External
+          class Slice < Hanami::Slice
+            config.root = __dir__
+          end
+        end
+      RUBY
+
+      # FIXME: Remove redundant `lib/` dir once hanami/hanami#1174 is merged
+      write "lib/external/lib/test_repo.rb", <<~'RUBY'
+        require "hanami/slice"
+
+        module External
+          class TestRepo
+            def things
+              %w[foo bar baz]
+            end
+          end
+        end
+      RUBY
+
+      write "lib/external/actions/test_action.rb", <<~'RUBY'
+        require "hanami/action"
+
+        module External
+          module Actions
+            class TestAction < Hanami::Action
+              include Deps["test_repo"]
+
+              def handle(req, res)
+                res.body = test_repo.things.join(", ")
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:external]).to be External::Slice
+
+      get "/"
+
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq "foo, bar, baz"
+    end
+  end
+end

data/spec/new_integration/slices/slice_configuration_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+RSpec.describe "Slices / Slice configuration", :app_integration do
+  specify "Slices receive a copy of the app configuration, and can make distinct modifications" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+
+            config.no_auto_register_paths << "structs"
+          end
+        end
+      RUBY
+
+      write "config/slices/main.rb", <<~'RUBY'
+        module Main
+          class Slice < Hanami::Slice
+            config.no_auto_register_paths << "schemas"
+          end
+        end
+      RUBY
+
+      write "config/slices/search.rb", <<~'RUBY'
+        module Search
+          class Slice < Hanami::Slice
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(TestApp::App.config.no_auto_register_paths).to eq %w[entities structs]
+      expect(Main::Slice.config.no_auto_register_paths).to eq %w[entities structs schemas]
+      expect(Search::Slice.config.no_auto_register_paths).to eq %w[entities structs]
+    end
+  end
+end

data/spec/new_integration/slices/slice_routing_spec.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Slices / Slice routing", :app_integration do
+  include Rack::Test::Methods
+
+  let(:app) { Main::Slice.rack_app }
+
+  specify "Slices have a nil router when no routes are defined" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~'RUBY'
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "slices/main/.keep", ""
+
+      require "hanami/prepare"
+
+      expect(Main::Slice.routes).to be nil
+      expect(Main::Slice.router).to be nil
+    end
+  end
+
+  specify "Slices have the app 'routes' component registered when app routes are defined but not their own" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~'RUBY'
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+          end
+        end
+      RUBY
+
+      write "config/routes.rb", <<~'RUBY'
+        require "hanami/routes"
+
+        module TestApp
+          class Routes < Hanami::Routes
+            define do
+              get "home", to: "home.show", as: :home
+            end
+          end
+        end
+      RUBY
+
+      write "slices/main/.keep", ""
+
+      require "hanami/prepare"
+
+      expect(Main::Slice["routes"].path(:home)).to eq "/home"
+
+      expect(Main::Slice.router).to be nil
+      expect(TestApp::App.router).not_to be nil
+    end
+  end
+
+  specify "Slices use their own router and registered 'routes' component when their own routes are defined" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~'RUBY'
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            config.logger.stream = File.new("/dev/null", "w")
+          end
+        end
+      RUBY
+
+      write "slices/main/config/routes.rb", <<~'RUBY'
+        require "hanami/routes"
+
+        module Main
+          class Routes < Hanami::Routes
+            define do
+              get "home", to: "home.show", as: :home
+            end
+          end
+        end
+      RUBY
+
+      write "slices/main/actions/home/show.rb", <<~'RUBY'
+        require "hanami/action"
+
+        module Main
+          module Actions
+            module Home
+              class Show < Hanami::Action
+                def handle(*, res)
+                  res.body = "Hello world"
+                end
+              end
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+      Main::Slice.boot
+
+      expect(Main::Slice["routes"].path(:home)).to eq "/home"
+
+      get "/home"
+
+      expect(last_response.status).to eq 200
+      expect(last_response.body).to eq "Hello world"
+    end
+  end
+
+  describe "Mounting slice routes" do
+    before :context 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")
+            end
+          end
+        RUBY
+
+        write "config/routes.rb", <<~'RUBY'
+          module TestApp
+            class Routes < Hanami::Routes
+              define do
+                root to: "home.show"
+
+                slice :main, at: "/main"
+              end
+            end
+          end
+        RUBY
+
+        write "app/actions/home/show.rb", <<~'RUBY'
+          require "hanami/action"
+
+          module TestApp
+            module Actions
+              module Home
+                class Show < Hanami::Action
+                  def handle(*, res)
+                    res.body = "Hello from app"
+                  end
+                end
+              end
+            end
+          end
+        RUBY
+
+        write "slices/main/config/routes.rb", <<~'RUBY'
+          module Main
+            class Routes < Hanami::Routes
+              define do
+                root to: "home.show"
+              end
+            end
+          end
+        RUBY
+
+        write "slices/main/actions/home/show.rb", <<~'RUBY'
+          require "hanami/action"
+
+          module Main
+            module Actions
+              module Home
+                class Show < Hanami::Action
+                  def handle(*, res)
+                    res.body = "Hello from slice"
+                  end
+                end
+              end
+            end
+          end
+        RUBY
+      end
+    end
+
+    let(:app) { TestApp::App.app }
+
+    describe "A slice with its own router can be mounted in its parent's routes" do
+      context "prepared" do
+        before do
+          with_directory(@dir) { require "hanami/prepare" }
+        end
+
+        specify do
+          get "/"
+
+          expect(last_response.status).to eq 200
+          expect(last_response.body).to eq "Hello from app"
+
+          get "/main"
+
+          expect(last_response.status).to eq 200
+          expect(last_response.body).to eq "Hello from slice"
+        end
+      end
+
+      context "booted" do
+        before do
+          with_directory(@dir) { require "hanami/boot" }
+        end
+
+        specify do
+          get "/"
+
+          expect(last_response.status).to eq 200
+          expect(last_response.body).to eq "Hello from app"
+
+          get "/main"
+
+          expect(last_response.status).to eq 200
+          expect(last_response.body).to eq "Hello from slice"
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/slices/slice_settings_spec.rb

@@ -0,0 +1,141 @@
+RSpec.describe "Slices / Slice settings", :app_integration do
+  specify "Settings are registered for each slice with a settings file" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      # The main slice has settings
+      write "slices/main/config/settings.rb", <<~RUBY
+        # frozen_string_literal: true
+
+        require "hanami/settings"
+
+        module Main
+          class Settings < Hanami::Settings
+            setting :main_session_secret
+          end
+        end
+      RUBY
+
+      # The admin slice has none
+      write "slices/admin/.keep", ""
+
+      require "hanami/prepare"
+
+      expect(Main::Slice.key?("settings")).to be true
+      expect(Main::Slice["settings"]).to respond_to :main_session_secret
+
+      expect(Admin::Slice.key?("settings")).to be false
+    end
+  end
+
+  describe "App settings are shared with slices if no local settings are defined" do
+    context "prepared" do
+      specify 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/settings.rb", <<~'RUBY'
+            # frozen_string_literal: true
+
+            require "hanami/settings"
+
+            module TestApp
+              class Settings < Hanami::Settings
+                setting :app_session_secret
+              end
+            end
+          RUBY
+
+          write "slices/main/config/settings.rb", <<~RUBY
+            # frozen_string_literal: true
+
+            require "hanami/settings"
+
+            module Main
+              class Settings < Hanami::Settings
+                setting :main_session_secret
+              end
+            end
+          RUBY
+
+          write "slices/admin/.keep", ""
+
+          require "hanami/prepare"
+
+          expect(TestApp::App.key?("settings")).to be true
+          expect(Main::Slice.key?("settings")).to be true
+          expect(Admin::Slice.key?("settings")).to be true
+
+          expect(TestApp::App["settings"]).to respond_to :app_session_secret
+          expect(Main::Slice["settings"]).to respond_to :main_session_secret
+          expect(Admin::Slice["settings"]).to respond_to :app_session_secret
+        end
+      end
+    end
+
+    context "booted" do
+      specify 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/settings.rb", <<~'RUBY'
+            # frozen_string_literal: true
+
+            require "hanami/settings"
+
+            module TestApp
+              class Settings < Hanami::Settings
+                setting :app_session_secret
+              end
+            end
+          RUBY
+
+          write "slices/main/config/settings.rb", <<~RUBY
+            # frozen_string_literal: true
+
+            require "hanami/settings"
+
+            module Main
+              class Settings < Hanami::Settings
+                setting :main_session_secret
+              end
+            end
+          RUBY
+
+          write "slices/admin/.keep", ""
+
+          require "hanami/boot"
+
+          expect(TestApp::App.key?("settings")).to be true
+          expect(Main::Slice.key?("settings")).to be true
+          expect(Admin::Slice.key?("settings")).to be true
+
+          expect(TestApp::App["settings"]).to respond_to :app_session_secret
+          expect(Main::Slice["settings"]).to respond_to :main_session_secret
+          expect(Admin::Slice["settings"]).to respond_to :app_session_secret
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/slices_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+RSpec.describe "Slices", :app_integration do
+  it "Loading a slice uses a defined slice 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 "config/slices/main.rb", <<~RUBY
+        module Main
+          class Slice < Hanami::Slice
+          end
+        end
+      RUBY
+
+      write "slices/main/lib/foo.rb", <<~RUBY
+        module Main
+          class Foo; end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main]).to be Main::Slice
+    end
+  end
+
+  it "Loading a slice with a defined slice class but no slice dir" 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/slices/main.rb", <<~RUBY
+        module Main
+          class Slice < Hanami::Slice
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main]).to be Main::Slice
+    end
+  end
+
+  it "Loading a slice generates a slice class if none is defined" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+      RUBY
+
+      write "slices/main/lib/foo.rb", <<~RUBY
+        module Main
+          class Foo; end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main]).to be Main::Slice
+    end
+  end
+
+  it "Registering a slice with a block creates a slice class and evals the block" do
+    with_tmp_directory(Dir.mktmpdir) do
+      write "config/app.rb", <<~RUBY
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+            register_slice :main do
+              register "greeting", "hello world"
+            end
+          end
+        end
+      RUBY
+
+      require "hanami/prepare"
+
+      expect(Hanami.app.slices[:main]).to be Main::Slice
+      expect(Main::Slice["greeting"]).to eq "hello world"
+    end
+  end
+end

data/spec/new_integration/view/configuration_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "hanami"
+
+RSpec.describe "App view / Configuration", :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+        config.root = "/test_app"
+      end
+    end
+
+    Hanami.app.instance_eval(&app_hook) if respond_to?(:app_hook)
+    Hanami.app.register_slice :main
+    Hanami.app.prepare
+
+    module TestApp
+      class View < Hanami::View
+      end
+    end
+  end
+
+  let(:view_class) { TestApp::View }
+
+  subject(:config) { view_class.config }
+
+  it "applies default view configuration from the app" do
+    aggregate_failures do
+      expect(config.layouts_dir).to eq "layouts"
+      expect(config.layout).to eq "app"
+    end
+  end
+
+  context "custom views configuration on app" do
+    let(:app_hook) {
+      proc do
+        config.views.layouts_dir = "custom_layouts"
+        config.views.layout = "my_layout"
+      end
+    }
+
+    it "applies the custom configuration" do
+      aggregate_failures do
+        expect(config.layouts_dir).to eq "custom_layouts"
+        expect(config.layout).to eq "my_layout"
+      end
+    end
+  end
+end