hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/dotenv_loading_spec.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-# rubocop:disable Style/FetchEnvVar
-
-RSpec.describe "Dotenv loading", :app_integration do
-  before do
-    @orig_env = ENV.to_h
-    allow(Hanami::Env).to receive(:loaded?).and_return(false)
-  end
-
-  after do
-    ENV.replace(@orig_env)
-  end
-
-  context "dotenv gem is available" do
-    before do
-      require "dotenv"
-    end
-
-    context "hanami env is development" do
-      it "loads .env.development.local, .env.local, .env.development and .env (in this order) into ENV", :aggregate_failures do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-              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/setup"
-
-          expect(ENV["FROM_SPECIFIC_ENV_LOCAL"]).to eq "from .env.development.local"
-          expect(ENV["FROM_BASE_LOCAL"]).to eq "from .env.local"
-          expect(ENV["FROM_SPECIFIC_ENV"]).to eq "from .env.development"
-          expect(ENV["FROM_BASE"]).to eq "from .env"
-        end
-      end
-    end
-
-    context "hanami env is test" do
-      it "loads .env.development.local, .env.development and .env (in this order) into ENV", :aggregate_failures do
-        with_tmp_directory(Dir.mktmpdir) do
-          write "config/app.rb", <<~'RUBY'
-            require "hanami"
-
-            module TestApp
-              class App < Hanami::App
-              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(ENV["FROM_SPECIFIC_ENV_LOCAL"]).to eq "from .env.test.local"
-          expect(ENV["FROM_BASE_LOCAL"]).to be nil
-          expect(ENV["FROM_SPECIFIC_ENV"]).to eq "from .env.test"
-          expect(ENV["FROM_BASE"]).to eq "from .env"
-        end
-      end
-    end
-  end
-
-  context "dotenv gem is unavailable" do
-    before do
-      allow_any_instance_of(Object).to receive(:gem).and_call_original
-      allow_any_instance_of(Object).to receive(:gem).with("dotenv").and_raise(Gem::LoadError)
-    end
-
-    it "does not load from .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 ".env", <<~'TEXT'
-          FOO=bar
-        TEXT
-
-        expect { require "hanami/prepare" }.not_to(change { ENV.to_h })
-        expect(ENV.key?("FOO")).to be false
-      end
-    end
-  end
-end
-
-# rubocop:enable Style/FetchEnvVar

data/spec/integration/logging/exception_logging_spec.rb

@@ -1,120 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-require "stringio"
-
-RSpec.describe "Logging / Exception logging", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  let(:logger_stream) { StringIO.new }
-
-  def configure_logger
-    Hanami.app.config.logger.stream = logger_stream
-  end
-
-  def logs
-    @logs ||= (logger_stream.rewind and logger_stream.read)
-  end
-
-  before do
-    with_directory(make_tmp_directory) do
-      write "config/app.rb", <<~RUBY
-        module TestApp
-          class App < Hanami::App
-            # Disable framework-level error rendering so we can test the raw action behavior
-            config.render_errors = false
-            config.render_detailed_errors = false
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            root to: "test"
-          end
-        end
-      RUBY
-
-      require "hanami/setup"
-      configure_logger
-
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  describe "unhandled exceptions" do
-    def before_prepare
-      write "app/actions/test.rb", <<~RUBY
-        module TestApp
-          module Actions
-            class Test < Hanami::Action
-              UnhandledError = Class.new(StandardError)
-
-              def handle(request, response)
-                raise UnhandledError, "unhandled"
-              end
-            end
-          end
-        end
-      RUBY
-    end
-
-    it "logs a 500 error and full exception details when an exception is raised" do
-      # Make the request with a rescue so the raised exception doesn't crash the tests
-      begin
-        get "/"
-      rescue TestApp::Actions::Test::UnhandledError # rubocop:disable Lint/SuppressedException
-      end
-
-      expect(logs.lines.length).to be > 10
-      expect(logs).to match %r{GET 500 \d+(µs|ms) 127.0.0.1 /}
-      expect(logs).to include("unhandled (TestApp::Actions::Test::UnhandledError)")
-
-      if RUBY_VERSION < "3.4"
-        expect(logs).to include("app/actions/test.rb:7:in `handle'")
-      else
-        expect(logs).to include("app/actions/test.rb:7:in 'TestApp::Actions::Test#handle'")
-      end
-    end
-
-    it "re-raises the exception" do
-      expect { get "/" }.to raise_error(TestApp::Actions::Test::UnhandledError)
-    end
-  end
-
-  describe "errors handled by handle_exception" do
-    def before_prepare
-      write "app/actions/test.rb", <<~RUBY
-        module TestApp
-          module Actions
-            class Test < Hanami::Action
-              NotFoundError = Class.new(StandardError)
-
-              handle_exception NotFoundError => :handle_not_found_error
-
-              def handle(request, response)
-                raise NotFoundError
-              end
-
-              private
-
-              def handle_not_found_error(request, response, exception)
-                halt 404
-              end
-            end
-          end
-        end
-      RUBY
-    end
-
-    it "does not log an error" do
-      get "/"
-
-      expect(logs).to match %r{GET 404 \d+(µs|ms) 127.0.0.1 /}
-    end
-  end
-end

data/spec/integration/logging/notifications_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require "rack/test"
-
-RSpec.describe "Logging / Notifications", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  specify "Request logging continues even when notifications bus has already been used" do
-    dir = Dir.mktmpdir
-
-    with_tmp_directory(dir) do
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.actions.format :json
-            config.logger.options = {colorize: true}
-            config.logger.stream = config.root.join("test.log")
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            post "/users", to: "users.create"
-          end
-        end
-      RUBY
-
-      write "app/actions/users/create.rb", <<~RUBY
-        module TestApp
-          module Actions
-            module Users
-              class Create < Hanami::Action
-                def handle(req, resp)
-                  resp.body = req.params.to_h.keys
-                end
-              end
-            end
-          end
-        end
-      RUBY
-
-      require "hanami/prepare"
-
-      # Simulate any component interacting with the notifications bus such that it creates its
-      # internal bus with a duplicate copy of all currently registered events. This means that the
-      # class-level Dry::Monitor::Notification events implicitly registered by the
-      # Dry::Monitor::Rack::Middleware activated via the rack provider are ignored, unless our
-      # provider explicitly re-registers them on _instance_ of the notifications bus.
-      #
-      # See Hanami::Providers::Rack for more detail.
-      Hanami.app["notifications"].instrument(:sql)
-
-      logs = -> { Pathname(dir).join("test.log").realpath.read }
-
-      post "/users", JSON.generate(name: "jane", password: "secret"), {"CONTENT_TYPE" => "application/json"}
-      expect(logs.()).to match %r{POST 200 \d+(µs|ms) 127.0.0.1 /}
-    end
-  end
-end
-
-
-

data/spec/integration/logging/request_logging_spec.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "rack/test"
-require "stringio"
-
-RSpec.describe "Logging / Request logging", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  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
-    @logs ||= (logger_stream.rewind and logger_stream.read)
-  end
-
-  def generate_app
-    write "config/app.rb", <<~RUBY
-    module TestApp
-      class App < Hanami::App
-      end
-    end
-    RUBY
-  end
-
-  before do
-    with_directory(root) do
-      generate_app
-
-      require "hanami/setup"
-      configure_logger
-
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  describe "app router" do
-    def before_prepare
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            root to: ->(env) { [200, {}, ["OK"]] }
-          end
-        end
-      RUBY
-    end
-
-    it "logs the requests" do
-      get "/"
-
-      expect(logs.split("\n").length).to eq 1
-      expect(logs).to match %r{GET 200 \d+(µs|ms) 127.0.0.1 /}
-    end
-
-    context "production env" do
-      around do |example|
-        @prev_hanami_env = ENV["HANAMI_ENV"]
-        ENV["HANAMI_ENV"] = "production"
-        example.run
-      ensure
-        ENV["HANAMI_ENV"] = @prev_hanami_env
-      end
-
-      it "logs the requests as JSON" do
-        get "/"
-
-        expect(logs.split("\n").length).to eq 1
-
-        json = JSON.parse(logs, symbolize_names: true)
-        expect(json).to include(
-          verb: "GET",
-          path: "/",
-          ip: "127.0.0.1",
-          elapsed: Integer,
-          elapsed_unit: a_string_matching(/(µs|ms)/),
-        )
-      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
-    let(:app) { Main::Slice.rack_app }
-
-    def before_prepare
-      write "slices/main/config/routes.rb", <<~RUBY
-        module Main
-          class Routes < Hanami::Routes
-            root to: ->(env) { [200, {}, ["OK"]] }
-          end
-        end
-      RUBY
-    end
-
-    it "logs the requests" do
-      get "/"
-
-      expect(logs.split("\n").length).to eq 1
-      expect(logs).to match %r{GET 200 \d+(µs|ms) 127.0.0.1 /}
-    end
-
-    context "production env" do
-      around do |example|
-        @prev_hanami_env = ENV["HANAMI_ENV"]
-        ENV["HANAMI_ENV"] = "production"
-        example.run
-      ensure
-        ENV["HANAMI_ENV"] = @prev_hanami_env
-      end
-
-      it "logs the requests as JSON" do
-        get "/"
-
-        expect(logs.split("\n").length).to eq 1
-
-        json = JSON.parse(logs, symbolize_names: true)
-        expect(json).to include(
-          verb: "GET",
-          path: "/",
-          ip: "127.0.0.1",
-          elapsed: Integer,
-          elapsed_unit: a_string_matching(/(µs|ms)/),
-        )
-      end
-    end
-  end
-
-  context "when using ::Logger from Ruby stdlib" do
-    def generate_app
-      write "config/app.rb", <<~RUBY
-        require "logger"
-        require "pathname"
-
-        module TestApp
-          class App < Hanami::App
-            stream = Pathname.new(#{root.to_s.inspect}).join("log").tap(&:mkpath).join("test.log").to_s
-            config.logger = ::Logger.new(stream, progname: "custom-logger-app")
-          end
-        end
-      RUBY
-    end
-
-    def before_prepare
-      with_directory(root) do
-        write "config/routes.rb", <<~RUBY
-          module TestApp
-            class Routes < Hanami::Routes
-              root to: ->(env) { [200, {}, ["OK"]] }
-            end
-          end
-        RUBY
-      end
-    end
-
-    let(:logs) do
-      Pathname.new(root).join("log", "test.log").readlines
-    end
-
-    it "logs the requests with the payload serialized as JSON" do
-      get "/"
-
-      request_log = logs.last
-
-      # Expected log line follows the standard Logger structure:
-      #
-      # I, [2023-10-14T14:55:16.638753 #94836]  INFO -- custom-logger-app: {"verb":"GET", ...}
-      expect(request_log).to match(%r{INFO -- custom-logger-app:})
-
-      # The log message should be JSON, after the progname
-      log_message = request_log.split("custom-logger-app: ").last
-      log_payload = JSON.parse(log_message, symbolize_names: true)
-
-      expect(log_payload).to include(
-        verb: "GET",
-        status: 200
-      )
-    end
-  end
-end

data/spec/integration/operations/extension_spec.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/operation"
-
-RSpec.describe "Operation / Extensions", :app_integration do
-  before do
-    @env = ENV.to_h
-    allow(Hanami::Env).to receive(:loaded?).and_return(false)
-  end
-
-  after { ENV.replace(@env) }
-
-  specify "Transaction interface is made available automatically" 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
-
-      write "slices/main/operation.rb", <<~RUBY
-        module Main
-          class Operation < Dry::Operation
-          end
-        end
-      RUBY
-
-      write "db/.keep", ""
-      write "app/relations/.keep", ""
-
-      write "slices/main/db/.keep", ""
-      write "slices/main/relations/.keep", ""
-
-      ENV["DATABASE_URL"] = "sqlite::memory"
-      ENV["MAIN__DATABASE_URL"] = "sqlite::memory"
-
-      require "hanami/prepare"
-
-      app = TestApp::Operation.new
-      main = Main::Operation.new
-
-      expect(app).to respond_to(:transaction)
-
-      expect(app.rom).to be TestApp::App["db.rom"]
-      expect(app.rom).not_to be Main::Slice["db.rom"]
-      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