hanami 2.0.0.beta1.1 → 2.0.0.beta3

data/spec/integration/settings/using_types_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "hanami/settings"
+
+RSpec.describe "Settings / Using types", :app_integration do
+  before do
+    @env = ENV.to_h
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  specify "dry-types can be used as setting constructors to coerce values" 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
+        require "dry/types"
+
+        module TestApp
+          class Settings < Hanami::Settings
+            Types = Dry.Types()
+
+            setting :numeric, constructor: Types::Params::Integer
+            setting :flag, constructor: Types::Params::Bool
+          end
+        end
+      RUBY
+
+      ENV["NUMERIC"] = "42"
+      ENV["FLAG"] = "true"
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["settings"].numeric).to eq 42
+      expect(Hanami.app["settings"].flag).to be true
+    end
+  end
+
+  specify "errors raised from setting constructors are collected and re-raised in aggregate" 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
+        require "dry/types"
+
+        module TestApp
+          class Settings < Hanami::Settings
+            Types = Dry.Types()
+
+            setting :numeric, constructor: Types::Params::Integer
+            setting :flag, constructor: Types::Params::Bool
+          end
+        end
+      RUBY
+
+      ENV["NUMERIC"] = "never gonna"
+      ENV["FLAG"] = "give you up"
+
+      numeric_error = "numeric: invalid value for Integer"
+      flag_error = "flag: give you up cannot be coerced"
+
+      expect {
+        require "hanami/prepare"
+      }.to raise_error(
+        Hanami::Settings::InvalidSettingsError,
+        /#{numeric_error}.+#{flag_error}|#{flag_error}.+#{numeric_error}/m
+      )
+    end
+  end
+
+end

data/spec/integration/setup_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+RSpec.describe "Hanami setup", :app_integration do
+  describe "Hanami.setup" do
+    shared_examples "hanami setup" do
+      it "requires the app file when found" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~RUBY
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          expect { setup }.to change { Hanami.app? }.to true
+          expect(Hanami.app).to be TestApp::App
+        end
+      end
+
+      it "requires the app file when found in a parent directory" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~RUBY
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write "lib/foo/bar/.keep"
+
+          Dir.chdir("lib/foo/bar") do
+            expect { setup }.to change { Hanami.app? }.to true
+            expect(Hanami.app).to be TestApp::App
+          end
+        end
+      end
+
+      it "raises when the app file is not found" do
+        with_tmp_directory(Dir.mktmpdir) do
+          expect { setup }.to raise_error Hanami::AppLoadError, /Could not locate your Hanami app file/
+        end
+      end
+
+      it "doesn't raise when the app file is not found but the app is already set" do
+        require "hanami"
+
+        module TestApp
+          class App < Hanami::App
+          end
+        end
+
+        expect { setup }.not_to raise_error
+      end
+
+      %w[hanami-view hanami-actions hanami-router].each do |gem_name|
+        it "works when #{gem_name} gem is not bundled" do
+          allow(Hanami).to receive(:bundled?).and_call_original
+          expect(Hanami).to receive(:bundled?).with("hanami-router").and_return(false)
+
+          with_tmp_directory(Dir.mktmpdir) do
+            write "config/app.rb", <<~RUBY
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+            RUBY
+
+            expect { setup }.to change { Hanami.app? }.to true
+          end
+        end
+      end
+    end
+
+    describe "using hanami/setup require" do
+      def setup
+        require "hanami/setup"
+      end
+
+      it_behaves_like "hanami setup"
+    end
+
+    describe "using Hanami.setup method" do
+      def setup(...)
+        require "hanami"
+        Hanami.setup(...)
+      end
+
+      it_behaves_like "hanami setup"
+
+      it "returns the loaded app when the app file is found" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~RUBY
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          # Multiple calls return the same app
+          expect(setup).to be(Hanami.app)
+          expect(setup).to be(Hanami.app)
+        end
+      end
+
+      it "returns nil when given `raise_exception: false` and the app file is not found" do
+        with_tmp_directory(Dir.mktmpdir) do
+          expect(setup(raise_exception: false)).to be nil
+        end
+      end
+    end
+  end
+
+  describe "Hanami.app_path" do
+    subject(:app_path) { Hanami.app_path }
+
+    context "config/app.rb exists in current directory" do
+      it "returns its absolute path" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb"
+
+          expect(app_path).to match(%r{^/.*/config/app.rb$})
+        end
+      end
+    end
+
+    context "config/app.rb exists in a parent directory" do
+      it "returns its absolute path" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb"
+          write "lib/foo/bar/.keep"
+
+          Dir.chdir("lib/foo/bar") do
+            expect(app_path).to match(%r{^/.*/config/app.rb$})
+          end
+        end
+      end
+    end
+
+    context "no app file in any directory" do
+      it "returns nil" do
+        with_tmp_directory(Dir.mktmpdir) do
+          expect(app_path).to be(nil)
+        end
+      end
+    end
+
+    context "directory exists with same name as the app file" do
+      it "returns nil" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb/.keep"
+
+          expect(app_path).to be(nil)
+        end
+      end
+    end
+  end
+end

data/spec/{new_integration → integration}/slices/external_slice_spec.rb

@@ -27,10 +27,8 @@ RSpec.describe "Slices / External slices", :app_integration do
 
         module TestApp
           class Routes < Hanami::Routes
-            define do
-              slice :external, at: "/" do
-                root to: "test_action"
-              end
+            slice :external, at: "/" do
+              root to: "test_action"
             end
           end
         end

data/spec/integration/slices/slice_loading_spec.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require "rack/test"
+
+RSpec.describe "Slices / Slice loading", :app_integration, :aggregate_failures do
+  let(:app_modules) { %i[TestApp Admin Editorial Main Shop] }
+
+  describe "loading specific slices with config.slices" do
+    describe "setup app" do
+      it "ignores any explicitly registered slices not included in load_slices" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+                config.slices = %w[admin]
+              end
+            end
+          RUBY
+
+          require "hanami/setup"
+
+          expect { Hanami.app.register_slice :main }.not_to(change { Hanami.app.slices.keys })
+          expect { Main }.to raise_error(NameError)
+
+          expect { Hanami.app.register_slice :admin }.to change { Hanami.app.slices.keys }.to [:admin]
+          expect(Admin::Slice).to be
+        end
+      end
+
+      describe "nested slices" do
+        it "ignores any explicitly registered slices not included in load_slices" do
+          with_tmp_directory(Dir.mktmpdir) do
+            write "config/app.rb", <<~'RUBY'
+              require "hanami"
+
+              module TestApp
+                class App < Hanami::App
+                  config.slices = %w[admin.shop]
+                end
+              end
+            RUBY
+
+            require "hanami/setup"
+
+            expect { Hanami.app.register_slice :admin }.to change { Hanami.app.slices.keys }.to [:admin]
+
+            expect { Admin::Slice.register_slice :editorial }.not_to(change { Admin::Slice.slices.keys })
+            expect { Admin::Slice.register_slice :shop }.to change { Admin::Slice.slices.keys }.to [:shop]
+            expect(Shop::Slice).to be
+          end
+        end
+      end
+    end
+
+    describe "prepared app" do
+      it "loads only the slices included in load_slices" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+                config.slices = %w[admin]
+              end
+            end
+          RUBY
+
+          write "slices/admin/.keep"
+          write "slices/main/.keep"
+
+          require "hanami/prepare"
+
+          expect(Hanami.app.slices.keys).to eq [:admin]
+          expect(Admin::Slice).to be
+          expect { Main }.to raise_error(NameError)
+        end
+      end
+
+      it "ignores unknown slices in load_slices" do
+        with_tmp_directory(Dir.mktmpdir) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+                config.slices = %w[admin meep morp]
+              end
+            end
+          RUBY
+
+          write "slices/admin/.keep"
+          write "slices/main/.keep"
+
+          require "hanami/prepare"
+
+          expect(Hanami.app.slices.keys).to eq [:admin]
+        end
+      end
+
+      describe "nested slices" do
+        it "loads only the dot-delimited nested slices (and their parents) included in load_slices" do
+          with_tmp_directory(Dir.mktmpdir) do
+            write "config/app.rb", <<~'RUBY'
+              require "hanami"
+
+              module TestApp
+                class App < Hanami::App
+                  config.slices = %w[admin.shop]
+                end
+              end
+            RUBY
+
+            write "slices/admin/.keep"
+            write "slices/admin/slices/shop/.keep"
+            write "slices/admin/slices/editorial/.keep"
+            write "slices/main/.keep"
+
+            require "hanami/prepare"
+
+            expect(Hanami.app.slices.keys).to eq [:admin]
+            expect(Admin::Slice.slices.keys).to eq [:shop]
+
+            expect(Admin::Slice).to be
+            expect(Shop::Slice).to be
+
+            expect { Editorial }.to raise_error(NameError)
+            expect { Main }.to raise_error(NameError)
+          end
+        end
+      end
+    end
+  end
+
+  describe "using ENV vars" do
+    before do
+      @orig_env = ENV.to_h
+    end
+
+    after do
+      ENV.replace(@orig_env)
+    end
+
+    it "uses HANAMI_SLICES" do
+      ENV["HANAMI_SLICES"] = "admin"
+
+      with_tmp_directory(Dir.mktmpdir) do
+        write "config/app.rb", <<~'RUBY'
+          require "hanami"
+
+          module TestApp
+            class App < Hanami::App
+            end
+          end
+        RUBY
+
+        write "slices/admin/.keep"
+        write "slices/main/.keep"
+
+        require "hanami/setup"
+
+        expect(Hanami.app.config.slices).to eq %w[admin]
+
+        require "hanami/prepare"
+
+        expect(Hanami.app.slices.keys).to eq [:admin]
+      end
+    end
+  end
+end

data/spec/{new_integration → integration}/slices/slice_routing_spec.rb

@@ -44,9 +44,7 @@ RSpec.describe "Slices / Slice routing", :app_integration do
 
         module TestApp
           class Routes < Hanami::Routes
-            define do
-              get "home", to: "home.show", as: :home
-            end
+            get "home", to: "home.show", as: :home
           end
         end
       RUBY
@@ -79,9 +77,7 @@ RSpec.describe "Slices / Slice routing", :app_integration do
 
         module Main
           class Routes < Hanami::Routes
-            define do
-              get "home", to: "home.show", as: :home
-            end
+            get "home", to: "home.show", as: :home
           end
         end
       RUBY
@@ -130,11 +126,9 @@ RSpec.describe "Slices / Slice routing", :app_integration do
         write "config/routes.rb", <<~'RUBY'
           module TestApp
             class Routes < Hanami::Routes
-              define do
-                root to: "home.show"
+              root to: "home.show"
 
-                slice :main, at: "/main"
-              end
+              slice :main, at: "/main"
             end
           end
         RUBY
@@ -158,9 +152,7 @@ RSpec.describe "Slices / Slice routing", :app_integration do
         write "slices/main/config/routes.rb", <<~'RUBY'
           module Main
             class Routes < Hanami::Routes
-              define do
-                root to: "home.show"
-              end
+              root to: "home.show"
             end
           end
         RUBY

data/spec/{new_integration → integration}/view/context/routes_spec.rb

@@ -17,9 +17,7 @@ RSpec.describe "App view / Context / Routes", :app_integration do
       write "config/routes.rb", <<~RUBY
         module TestApp
           class Routes < Hanami::Routes
-            define do
-              root to: "home.index"
-            end
+            root to: "home.index"
           end
         end
       RUBY

data/spec/{new_integration → integration}/view/context/settings_spec.rb

@@ -1,12 +1,16 @@
 # frozen_string_literal: true
 
 require "hanami"
+require "hanami/settings"
 
 RSpec.describe "App view / Context / Settings", :app_integration do
   before do
     module TestApp
       class App < Hanami::App
       end
+
+      class Settings < Hanami::Settings
+      end
     end
 
     Hanami.prepare
@@ -24,7 +28,7 @@ RSpec.describe "App view / Context / Settings", :app_integration do
 
   describe "#settings" do
     it "is the app settings by default" do
-      expect(context.settings).to be TestApp::App.settings
+      expect(context.settings).to be TestApp::App["settings"]
     end
 
     context "injected settings" do