hanami 2.3.2 → 3.0.0.rc1

data/spec/integration/web/render_errors_spec.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "rack/test"
-
-RSpec.describe "Web / Rendering errors", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  before 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")
-            config.render_errors = true
-            config.render_detailed_errors = false
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            get "index", to: "index"
-            get "error", to: "error"
-          end
-        end
-      RUBY
-
-      write "app/actions/index.rb", <<~RUBY
-        module TestApp
-          module Actions
-            class Index < Hanami::Action
-              def handle(*, response)
-                response.body = "Hello"
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "app/actions/error.rb", <<~RUBY
-        module TestApp
-          module Actions
-            class Error < Hanami::Action
-              def handle(*)
-                raise "oops"
-              end
-            end
-          end
-        end
-      RUBY
-
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  describe "HTML request" do
-    context "error pages present" do
-      def before_prepare
-        write "public/404.html", <<~HTML
-          <h1>Not found</h1>
-        HTML
-
-        write "public/500.html", <<~HTML
-          <h1>Error</h1>
-        HTML
-      end
-
-      it "responds with the HTML for a 404 from a not found error" do
-        get "/__not_found__"
-
-        expect(last_response.status).to eq 404
-        expect(last_response.body.strip).to eq "<h1>Not found</h1>"
-        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
-        expect(last_response.get_header("Content-Length")).to eq "19"
-      end
-
-      it "responds with the HTML for a 404 from a method not allowed error" do
-        post "/index"
-
-        expect(last_response.status).to eq 404
-        expect(last_response.body.strip).to eq "<h1>Not found</h1>"
-        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
-        expect(last_response.get_header("Content-Length")).to eq "19"
-      end
-
-      it "responds with the HTML for a 500" do
-        get "/error"
-
-        expect(last_response.status).to eq 500
-        expect(last_response.body.strip).to eq "<h1>Error</h1>"
-        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
-        expect(last_response.get_header("Content-Length")).to eq "15"
-      end
-    end
-
-    context "error pages missing" do
-      it "responds with default text for a 404 from a not found error" do
-        get "/__not_found__"
-
-        expect(last_response.status).to eq 404
-        expect(last_response.body.strip).to eq "Not Found"
-        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
-        expect(last_response.get_header("Content-Length")).to eq "9"
-      end
-
-      it "responds with default text for a 404 from a metohd not allowed error" do
-        post "/index"
-
-        expect(last_response.status).to eq 404
-        expect(last_response.body.strip).to eq "Not Found"
-        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
-        expect(last_response.get_header("Content-Length")).to eq "9"
-      end
-
-      it "responds with default text for a 500" do
-        get "/error"
-
-        expect(last_response.status).to eq 500
-        expect(last_response.body.strip).to eq "Internal Server Error"
-        expect(last_response.get_header("Content-Type")).to eq "text/html; charset=utf-8"
-        expect(last_response.get_header("Content-Length")).to eq "21"
-      end
-    end
-  end
-
-  describe "JSON request" do
-    it "renders a JSON response for a 404 from a not found error" do
-      get "/__not_found__", {}, "HTTP_ACCEPT" => "application/json"
-
-      expect(last_response.status).to eq 404
-      expect(last_response.body.strip).to eq %({"status":404,"error":"Not Found"})
-      expect(last_response.get_header("Content-Type")).to eq "application/json; charset=utf-8"
-      expect(last_response.get_header("Content-Length")).to eq "34"
-    end
-
-    it "renders a JSON response for a 404 from a metnod not allowed error" do
-      post "/index", {}, "HTTP_ACCEPT" => "application/json"
-
-      expect(last_response.status).to eq 404
-      expect(last_response.body.strip).to eq %({"status":404,"error":"Not Found"})
-      expect(last_response.get_header("Content-Type")).to eq "application/json; charset=utf-8"
-      expect(last_response.get_header("Content-Length")).to eq "34"
-    end
-
-    it "renders a JSON response for a 500" do
-      get "/error", {}, "HTTP_ACCEPT" => "application/json"
-
-      expect(last_response.status).to eq 500
-      expect(last_response.body.strip).to eq %({"status":500,"error":"Internal Server Error"})
-      expect(last_response.get_header("Content-Type")).to eq "application/json; charset=utf-8"
-      expect(last_response.get_header("Content-Length")).to eq "46"
-    end
-  end
-
-  describe "configuring error responses" do
-    def before_prepare
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          CustomNotFoundError = Class.new(StandardError)
-
-          class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
-            config.render_errors = true
-            config.render_error_responses["TestApp::CustomNotFoundError"] = :not_found
-            config.render_detailed_errors = false
-          end
-        end
-      RUBY
-
-      write "app/actions/error.rb", <<~RUBY
-        module TestApp
-          module Actions
-            class Error < Hanami::Action
-              def handle(*)
-                raise CustomNotFoundError
-              end
-            end
-          end
-        end
-      RUBY
-
-      write "public/404.html", <<~HTML
-        <h1>Not found</h1>
-      HTML
-    end
-
-    it "uses the configured errors to determine the response" do
-      get "/error"
-
-      expect(last_response.status).to eq 404
-      expect(last_response.body.strip).to eq "<h1>Not found</h1>"
-    end
-  end
-
-  describe "render_errors config disabled" do
-    def before_prepare
-      write "config/app.rb", <<~RUBY
-        require "hanami"
-
-        module TestApp
-          class App < Hanami::App
-            config.logger.stream = File.new("/dev/null", "w")
-            config.render_errors = false
-            config.render_detailed_errors = false
-          end
-        end
-      RUBY
-
-      # Include error pages here to prove they are _not_ used
-      write "public/404.html", <<~HTML
-        <h1>Not found</h1>
-      HTML
-
-      write "public/500.html", <<~HTML
-        <h1>Error</h1>
-      HTML
-    end
-
-    it "renders the hanami-router default 404 response for a not found error" do
-      get "/__not_found__"
-      expect(last_response.status).to eq 404
-    end
-
-    it "renders the hanami-router default 405 response for a not allowed error" do
-      post "/index"
-      expect(last_response.status).to eq 405
-    end
-
-    it "raises the original error for a 500" do
-      expect { get "/error" }.to raise_error(RuntimeError, "oops")
-    end
-  end
-end

data/spec/integration/web/welcome_view_spec.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-require "rack/test"
-
-RSpec.describe "Web / Welcome view", :app_integration do
-  include Rack::Test::Methods
-
-  let(:app) { Hanami.app }
-
-  before 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::NULL
-          end
-        end
-      RUBY
-
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-          end
-        end
-      RUBY
-
-      before_prepare if respond_to?(:before_prepare)
-      require "hanami/prepare"
-    end
-  end
-
-  context "no routes defined" do
-    it "renders the welcome page" do
-      get "/"
-
-      body = last_response.body.strip
-      expect(body).to include "<h1>Welcome to Hanami</h1>"
-      expect(body).to include "Hanami version: #{Hanami::VERSION}"
-      expect(body).to include "Ruby version: #{RUBY_DESCRIPTION}"
-
-      expect(last_response.status).to eq 200
-    end
-  end
-
-  context "routes defined" do
-    def before_prepare
-      write "config/routes.rb", <<~RUBY
-        module TestApp
-          class Routes < Hanami::Routes
-            root to: -> * { [200, {}, "Hello from a route"] }
-          end
-        end
-      RUBY
-    end
-
-    it "does not render the welcome page" do
-      get "/"
-
-      expect(last_response.body).to eq "Hello from a route"
-      expect(last_response.status).to eq 200
-    end
-  end
-
-  context "non-development env" do
-    def before_prepare
-      @hanami_env = ENV["HANAMI_ENV"]
-      ENV["HANAMI_ENV"] = "production"
-    end
-
-    after do
-      ENV["HANAMI_ENV"] = @hanami_env
-    end
-
-    it "does not render the welcome page" do
-      get "/"
-
-      expect(last_response.body).to eq "Not Found"
-      expect(last_response.status).to eq 404
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-
-SPEC_ROOT = File.expand_path(__dir__).freeze
-LOG_DIR = Pathname(SPEC_ROOT).join("..").join("log")
-
-require_relative "support/coverage" if ENV["COVERAGE"].eql?("true")
-
-require "hanami"
-begin; require "byebug"; rescue LoadError; end
-require "hanami/utils/file_list"
-require "hanami/devtools/unit"
-
-Hanami::Utils::FileList["./spec/support/**/*.rb"].each do |file|
-  next if file.include?("hanami-plugin")
-
-  require file
-end
-
-RSpec.configure do |config|
-  config.after(:suite) do
-    # TODO: Find out what causes logger to create this dir when running specs.
-    #       There's probably a test app class being created somewhere with root
-    #       not pointing to a tmp dir.
-    FileUtils.rm_rf(LOG_DIR) if LOG_DIR.exist?
-  end
-end

data/spec/support/app_integration.rb

@@ -1,157 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/devtools/integration/files"
-require "hanami/devtools/integration/with_tmp_directory"
-require "json"
-require "tmpdir"
-require "zeitwerk"
-
-module RSpec
-  module Support
-    module WithTmpDirectory
-      private
-
-      def make_tmp_directory
-        Pathname(Dir.mktmpdir).tap do |dir|
-          (@made_tmp_dirs ||= []) << dir
-        end
-      end
-    end
-
-    module App
-      def self.included(base)
-        super
-
-        base.class_eval do
-          let!(:node_modules_path) { File.join(Dir.pwd, "node_modules") }
-        end
-      end
-
-      private
-
-      # TODO: make slice-aware
-      def stub_assets(*assets)
-        manifest_hash = assets.each_with_object({}) { |source_path, hsh|
-          hsh[source_path] = {url: File.join("/assets", source_path)}
-        }
-
-        write "public/assets/assets.json", JSON.generate(manifest_hash)
-
-        # An assets dir is required to load the assets provider
-        write "app/assets/.keep", ""
-      end
-
-      def compile_assets!
-        link_node_modules
-        generate_assets_config
-
-        require "hanami/cli/command"
-        require "hanami/cli/commands/app/command"
-        require "hanami/cli/commands/app/assets/compile"
-        assets_compile = Hanami::CLI::Commands::App::Assets::Compile.new(
-          config: Hanami.app.config.assets,
-          out: File.new(File::NULL, "w"),
-          err: File.new(File::NULL, "w"),
-        )
-
-        with_directory(Hanami.app.root) { assets_compile.call }
-      end
-
-      def link_node_modules
-        root = Hanami.app.root
-
-        return if File.exist?(File.join(root, "node_modules", "hanami-assets", "dist", "hanami-assets.js"))
-
-        FileUtils.ln_s(node_modules_path, root)
-      rescue Errno::EEXIST # rubocop:disable Lint/SuppressedException
-      end
-
-      def generate_assets_config
-        root = Hanami.app.root
-
-        with_directory(root) do
-          write("config/assets.js", <<~JS) unless root.join("config", "assets.js").exist?
-            import * as assets from "hanami-assets";
-            await assets.run();
-          JS
-
-          write("package.json", <<~JSON) unless root.join("package.json").exist?
-            {
-              "type": "module"
-            }
-          JSON
-        end
-      end
-    end
-  end
-end
-
-RSpec.shared_context "App integration" do
-  let(:app_modules) { %i[TestApp Admin Main Search] }
-end
-
-def autoloaders_teardown!
-  ObjectSpace.each_object(Zeitwerk::Loader) do |loader|
-    loader.unregister if loader.dirs.any? { |dir|
-      dir.include?("/spec/") || dir.include?(Dir.tmpdir) ||
-        dir.include?("/slices/") || dir.include?("/app")
-    }
-  end
-end
-
-RSpec.configure do |config|
-  config.include RSpec::Support::Files, :app_integration
-  config.include RSpec::Support::WithTmpDirectory, :app_integration
-  config.include RSpec::Support::App, :app_integration
-  config.include_context "App integration", :app_integration
-
-  config.before :each, :app_integration do
-    # Conditionally assign these in case they have been assigned earlier for specific
-    # example groups (e.g. container/prepare_container_spec.rb)
-    @load_paths ||= $LOAD_PATH.dup
-    @loaded_features ||= $LOADED_FEATURES.dup
-  end
-
-  config.after :each, :app_integration do
-    autoloaders_teardown!
-
-    Hanami.instance_variable_set(:@_bundled, {})
-    Hanami.remove_instance_variable(:@_app) if Hanami.instance_variable_defined?(:@_app)
-
-    # Disconnect and clear cached DB gateways across slices
-    Hanami::Providers::DB.cache.values.map(&:disconnect)
-    Hanami::Providers::DB.cache.clear
-
-    $LOAD_PATH.replace(@load_paths)
-
-    # Remove example-specific LOADED_FEATURES added when running each example
-    new_features_to_keep = ($LOADED_FEATURES - @loaded_features).tap { |feats|
-      feats.delete_if do |path|
-        path =~ %r{hanami/(setup|prepare|boot|application/container/providers)} ||
-          path.include?(SPEC_ROOT.to_s) ||
-          path.include?(Dir.tmpdir)
-      end
-    }
-    $LOADED_FEATURES.replace(@loaded_features + new_features_to_keep)
-
-    app_modules.each do |app_module_name|
-      next unless Object.const_defined?(app_module_name)
-
-      Object.const_get(app_module_name).tap do |mod|
-        mod.constants.each do |name|
-          mod.send(:remove_const, name)
-        end
-      end
-
-      Object.send(:remove_const, app_module_name)
-    end
-  end
-
-  config.after :all do
-    if instance_variable_defined?(:@made_tmp_dirs)
-      Array(@made_tmp_dirs).each do |dir|
-        FileUtils.remove_entry dir
-      end
-    end
-  end
-end

data/spec/support/coverage.rb

@@ -1 +0,0 @@
-require "hanami/devtools/unit/support/coverage"

data/spec/support/matchers.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RSpec
-  module Support
-    module Matchers
-      module HTML
-        def squish_html(str)
-          str
-            .gsub(/^[[:space:]]+/, "")
-            .gsub(/>[[:space:]]+</m, "><")
-            .strip
-        end
-      end
-    end
-  end
-end
-
-RSpec::Matchers.define :eq_html do |expected_html|
-  include RSpec::Support::Matchers::HTML
-
-  match do |actual_html|
-    squish_html(actual_html) == squish_html(expected_html)
-  end
-end
-
-RSpec::Matchers.define :include_html do |expected_html|
-  include RSpec::Support::Matchers::HTML
-
-  match do |actual_html|
-    squish_html(actual_html).include?(squish_html(expected_html))
-  end
-end

data/spec/support/rspec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.before :suite do
-    require "hanami/devtools/integration"
-    Pathname.new(Dir.pwd).join("tmp").mkpath
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-
-  config.filter_run_when_matching :focus
-  config.disable_monkey_patching!
-  config.warnings = false
-
-  config.default_formatter = "doc" if config.files_to_run.one?
-
-  config.order = :random
-  Kernel.srand config.seed
-end

data/spec/unit/hanami/config/actions/content_security_policy_spec.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config/actions"
-
-RSpec.describe Hanami::Config::Actions, "#content_security_policy" do
-  let(:app_config) { Hanami::Config.new(app_name: "MyApp::App", env: :development) }
-  let(:config) { app_config.actions }
-  subject(:content_security_policy) { config.content_security_policy }
-
-  context "no CSP config specified" do
-    it "has defaults" do
-      expect(content_security_policy[:base_uri]).to eq("'self'")
-
-      expected = [
-        %(base-uri 'self'),
-        %(child-src 'self'),
-        %(connect-src 'self'),
-        %(default-src 'none'),
-        %(font-src 'self'),
-        %(form-action 'self'),
-        %(frame-ancestors 'self'),
-        %(frame-src 'self'),
-        %(img-src 'self' https: data:),
-        %(media-src 'self'),
-        %(object-src 'none'),
-        %(script-src 'self'),
-        %(style-src 'self' 'unsafe-inline' https:)
-      ].join(";")
-
-      expect(content_security_policy.to_s).to eq(expected)
-      expect(content_security_policy.nonce?).to be(false)
-    end
-  end
-
-  context "CSP settings specified" do
-    let(:cdn_url) { "https://assets.hanamirb.test" }
-
-    it "appends to default values" do
-      content_security_policy[:script_src] += " #{cdn_url}"
-
-      expect(content_security_policy[:script_src]).to eq("'self' #{cdn_url}")
-      expect(content_security_policy.to_s).to match("'self' #{cdn_url}")
-    end
-
-    it "overrides default values" do
-      content_security_policy[:style_src] = cdn_url
-
-      expect(content_security_policy[:style_src]).to eq(cdn_url)
-      expect(content_security_policy.to_s).to match(cdn_url)
-    end
-
-    it "nullifies value" do
-      content_security_policy[:object_src] = nil
-
-      expect(content_security_policy[:object_src]).to be(nil)
-      expect(content_security_policy.to_s).to match("object-src ;")
-    end
-
-    it "deletes key" do
-      content_security_policy.delete(:object_src)
-
-      expect(content_security_policy[:object_src]).to be(nil)
-      expect(content_security_policy.to_s).to_not match("object-src")
-    end
-
-    it "adds a custom key" do
-      content_security_policy[:a_custom_key] = "foo"
-
-      expect(content_security_policy[:a_custom_key]).to eq("foo")
-      expect(content_security_policy.to_s).to match("a-custom-key foo")
-    end
-
-    it "uses 'nonce' in value" do
-      content_security_policy[:javascript_src] = "'self' 'nonce'"
-
-      expect(content_security_policy.nonce?).to be(true)
-    end
-  end
-
-  context "with CSP enabled" do
-    it "sets default header" do
-      app_config.finalize!
-
-      expect(config.default_headers.fetch("Content-Security-Policy")).to eq(content_security_policy.to_s)
-    end
-  end
-
-  context "with CSP disabled" do
-    it "doesn't set default header" do
-      config.content_security_policy = false
-      app_config.finalize!
-
-      expect(config.default_headers.key?("Content-Security-Policy")).to be(false)
-    end
-  end
-end