hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/settings/settings_component_loading_spec.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Settings / Component loading", :app_integration do
-  describe "Settings are loaded from a class defined in config/settings.rb" do
-    specify "in app" do
-      with_directory(make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "config/settings.rb", <<~'RUBY'
-          module TestApp
-            class Settings < Hanami::Settings
-              setting :foo
-            end
-          end
-        RUBY
-
-        require "hanami/prepare"
-
-        expect(Hanami.app["settings"]).to be_an_instance_of TestApp::Settings
-        expect(Hanami.app["settings"]).to respond_to :foo
-      end
-    end
-
-    specify "in slice" do
-      with_directory(make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "slices/main/config/settings.rb", <<~'RUBY'
-          module Main
-            class Settings < Hanami::Settings
-              setting :foo
-            end
-          end
-        RUBY
-
-        require "hanami/prepare"
-
-        expect(Main::Slice["settings"]).to be_an_instance_of Main::Settings
-        expect(Main::Slice["settings"]).to respond_to :foo
-      end
-    end
-  end
-
-  describe "Settings are loaded from a `Settings` class if already defined" do
-    specify "in app" do
-      with_directory(make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-          require "hanami/settings"
-
-          module TestApp
-            class App < Hanami::App
-            end
-
-            class Settings < Hanami::Settings
-              setting :foo
-            end
-          end
-        RUBY
-
-        require "hanami/prepare"
-
-        expect(Hanami.app["settings"]).to be_an_instance_of TestApp::Settings
-        expect(Hanami.app["settings"]).to respond_to :foo
-      end
-    end
-
-    specify "in slice" do
-      with_directory(make_tmp_directory) do
-        write "config/app.rb", <<~'RUBY'
-          require "hanami"
-
-          module TestApp
-            class App < Hanami::App
-            end
-          end
-        RUBY
-
-        write "config/slices/main.rb", <<~'RUBY'
-          require "hanami/settings"
-
-          module Main
-            class Slice < Hanami::Slice
-            end
-
-            class Settings < Hanami::Settings
-              setting :foo
-            end
-          end
-        RUBY
-
-        require "hanami/prepare"
-
-        expect(Main::Slice["settings"]).to be_an_instance_of Main::Settings
-        expect(Main::Slice["settings"]).to respond_to :foo
-      end
-    end
-  end
-end

data/spec/integration/settings/slice_registration_spec.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe "Settings / Slice registration", :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
-
-      # n.b. no app-level settings file
-
-      # 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/integration/settings/using_types_spec.rb

@@ -1,80 +0,0 @@
-# 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 "types from a provided types module 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
-        module TestApp
-          class Settings < Hanami::Settings
-            Bool = Types::Params::Bool
-
-            setting :numeric, constructor: Types::Params::Integer
-            setting :flag, constructor: 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, and will prevent the app from booting" 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
-        module TestApp
-          class Settings < Hanami::Settings
-            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

@@ -1,165 +0,0 @@
-# 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_s).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_s).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/integration/slices/external_slice_spec.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-require "stringio"
-
-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 = StringIO.new
-
-            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
-            slice :external, at: "/" do
-              root to: "test_action"
-            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/integration/slices/slice_configuration_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "stringio"
-
-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 = StringIO.new
-
-            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[structs]
-      expect(Main::Slice.config.no_auto_register_paths).to eq %w[structs schemas]
-      expect(Search::Slice.config.no_auto_register_paths).to eq %w[structs]
-    end
-  end
-end