hanami 2.0.0.beta1.1 → 2.0.0.beta2

data/spec/new_integration/settings/access_to_constants_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+RSpec.describe "Settings / Access to constants", :app_integration do
+  before do
+    @env = ENV.to_h
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  describe "Settings can access autoloadable constants" do
+    describe "settings for app" do
+      specify "constant defined in app directory" do
+        with_directory(make_tmp_directory) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write ".env", <<~'TEXT'
+            SOME_FLAG=true
+          TEXT
+
+          write "config/settings.rb", <<~'RUBY'
+            module TestApp
+              class Settings < Hanami::Settings
+                setting :some_flag, constructor: Types::Params::Bool
+              end
+            end
+          RUBY
+
+          write "app/types.rb", <<~'RUBY'
+            # auto_register: false
+
+            require "dry/types"
+
+            module TestApp
+              Types = Dry.Types()
+            end
+          RUBY
+
+          require "hanami/prepare"
+
+          expect(Hanami.app[:settings].some_flag).to be true
+        end
+      end
+
+      specify "constant defined in root lib directory" do
+        with_directory(make_tmp_directory) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write ".env", <<~'TEXT'
+            SOME_FLAG=true
+          TEXT
+
+          write "config/settings.rb", <<~'RUBY'
+            module TestApp
+              class Settings < Hanami::Settings
+                setting :some_flag, constructor: Types::Params::Bool
+              end
+            end
+          RUBY
+
+          write "lib/test_app/types.rb", <<~'RUBY'
+            require "dry/types"
+
+            module TestApp
+              Types = Dry.Types()
+            end
+          RUBY
+
+          require "hanami/prepare"
+
+          expect(Hanami.app[:settings].some_flag).to be true
+        end
+      end
+    end
+
+    describe "settings for slice" do
+      specify "constant defined in slice directory" do
+        with_directory(make_tmp_directory) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write ".env", <<~'TEXT'
+            SOME_FLAG=true
+          TEXT
+
+          write "slices/main/config/settings.rb", <<~'RUBY'
+            module Main
+              class Settings < Hanami::Settings
+                setting :some_flag, constructor: Types::Params::Bool
+              end
+            end
+          RUBY
+
+          write "slices/main/types.rb", <<~'RUBY'
+            # auto_register: false
+
+            require "dry/types"
+
+            module Main
+              Types = Dry.Types()
+            end
+          RUBY
+
+          require "hanami/prepare"
+
+          expect(Main::Slice[:settings].some_flag).to be true
+        end
+      end
+
+      specify "constant defined in root lib directory" do
+        with_directory(make_tmp_directory) do
+          write "config/app.rb", <<~'RUBY'
+            require "hanami"
+
+            module TestApp
+              class App < Hanami::App
+              end
+            end
+          RUBY
+
+          write ".env", <<~'TEXT'
+            SOME_FLAG=true
+          TEXT
+
+          write "slices/main/config/settings.rb", <<~'RUBY'
+            module Main
+              class Settings < Hanami::Settings
+                setting :some_flag, constructor: TestApp::Types::Params::Bool
+              end
+            end
+          RUBY
+
+          write "lib/test_app/types.rb", <<~'RUBY'
+            require "dry/types"
+
+            module TestApp
+              Types = Dry.Types()
+            end
+          RUBY
+
+          require "hanami/prepare"
+
+          expect(Main::Slice[:settings].some_flag).to be true
+        end
+      end
+    end
+  end
+end

data/spec/new_integration/settings/loading_from_env_spec.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+RSpec.describe "Settings / Access to constants", :app_integration do
+  before do
+    @env = ENV.to_h
+  end
+
+  after do
+    ENV.replace(@env)
+  end
+
+  specify "settings are loaded from ENV" 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 :database_url
+          end
+        end
+      RUBY
+
+      ENV["DATABASE_URL"] = "postgres://localhost/database"
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["settings"].database_url).to eq "postgres://localhost/database"
+    end
+  end
+
+  describe "settings are loaded from .env files" do
+    context "hanami env is development" do
+      it "loads settings from .env.development.local, .env.local, .env.development and .env (in this order)" 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 :from_specific_env_local
+                setting :from_base_local
+                setting :from_specific_env
+                setting :from_base
+              end
+            end
+          RUBY
+
+          write ".env.development.local", <<~'TEXT'
+            FROM_SPECIFIC_ENV_LOCAL="from .env.development.local"
+          TEXT
+
+          write ".env.local", <<~'TEXT'
+            FROM_BASE_LOCAL="from .env.local"
+
+            FROM_SPECIFIC_ENV_LOCAL=nope
+          TEXT
+
+          write ".env.development", <<~'TEXT'
+            FROM_SPECIFIC_ENV="from .env.development"
+
+            FROM_SPECIFIC_ENV_LOCAL=nope
+            FROM_BASE_LOCAL=nope
+          TEXT
+
+          write ".env", <<~'TEXT'
+            FROM_BASE="from .env"
+
+            FROM_SPECIFIC_ENV_LOCAL=nope
+            FROM_BASE_LOCAL=nope
+            FROM_SPECIFIC_ENV=nope
+          TEXT
+
+          ENV["HANAMI_ENV"] = "development"
+
+          require "hanami/prepare"
+
+          expect(Hanami.app["settings"].from_specific_env_local).to eq "from .env.development.local"
+          expect(Hanami.app["settings"].from_base_local).to eq "from .env.local"
+          expect(Hanami.app["settings"].from_specific_env).to eq "from .env.development"
+          expect(Hanami.app["settings"].from_base).to eq "from .env"
+        end
+      end
+
+      context "hanami env is test" do
+        it "loads settings from .env.development.local, .env.development and .env (in this order)" 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 :from_specific_env_local
+                  setting :from_base_local
+                  setting :from_specific_env
+                  setting :from_base
+                end
+              end
+            RUBY
+
+            write ".env.test.local", <<~'TEXT'
+              FROM_SPECIFIC_ENV_LOCAL="from .env.test.local"
+            TEXT
+
+            write ".env.local", <<~'TEXT'
+              FROM_BASE_LOCAL="from .env.local"
+            TEXT
+
+            write ".env.test", <<~'TEXT'
+              FROM_SPECIFIC_ENV="from .env.test"
+
+              FROM_SPECIFIC_ENV_LOCAL=nope
+            TEXT
+
+            write ".env", <<~'TEXT'
+              FROM_BASE="from .env"
+
+              FROM_SPECIFIC_ENV_LOCAL=nope
+              FROM_SPECIFIC_ENV=nope
+            TEXT
+
+            ENV["HANAMI_ENV"] = "test"
+
+            require "hanami/prepare"
+
+            expect(Hanami.app["settings"].from_specific_env_local).to eq "from .env.test.local"
+            expect(Hanami.app["settings"].from_base_local).to be nil
+            expect(Hanami.app["settings"].from_specific_env).to eq "from .env.test"
+            expect(Hanami.app["settings"].from_base).to eq "from .env"
+          end
+        end
+      end
+    end
+  end
+
+  it "prefers ENV values are preferred over .env files" 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 :database_url
+          end
+        end
+      RUBY
+
+      write ".env", <<~'TEXT'
+        DATABASE_URL=nope
+      TEXT
+
+      ENV["DATABASE_URL"] = "postgres://localhost/database"
+
+      require "hanami/prepare"
+
+      expect(Hanami.app["settings"].database_url).to eq "postgres://localhost/database"
+    end
+  end
+end

data/spec/new_integration/settings/settings_component_loading_spec.rb

@@ -0,0 +1,113 @@
+# 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/new_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/new_integration/setup_spec.rb

@@ -0,0 +1,145 @@
+# 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
+    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