hanami 2.3.2 → 3.0.0

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

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config/actions"
-
-RSpec.describe Hanami::Config::Actions, "#cookies" do
-  let(:config) { described_class.new }
-  subject(:cookies) { config.cookies }
-
-  context "default config" do
-    it "is enabled" do
-      expect(cookies).to be_enabled
-    end
-
-    it "is an empty hash" do
-      expect(cookies.to_h).to eq({})
-    end
-  end
-
-  context "options given" do
-    before do
-      config.cookies = {max_age: 300}
-    end
-
-    it "is enabled" do
-      expect(cookies).to be_enabled
-    end
-
-    it "returns the given options" do
-      expect(cookies.to_h).to eq(max_age: 300)
-    end
-  end
-
-  context "nil value given" do
-    before do
-      config.cookies = nil
-    end
-
-    it "is not enabled" do
-      expect(cookies).not_to be_enabled
-    end
-
-    it "returns an empty hash" do
-      expect(cookies.to_h).to eq({})
-    end
-  end
-end

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

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config/actions"
-
-RSpec.describe Hanami::Config::Actions, "#csrf_protection" do
-  let(:app_config) { Hanami::Config.new(app_name: "MyApp::App", env: :development) }
-  let(:config) { app_config.actions }
-  subject(:value) { config.csrf_protection }
-
-  context "non-finalized config" do
-    it "returns a default of nil" do
-      is_expected.to be_nil
-    end
-
-    it "can be explicitly enabled" do
-      config.csrf_protection = true
-      is_expected.to be true
-    end
-
-    it "can be explicitly disabled" do
-      config.csrf_protection = false
-      is_expected.to be false
-    end
-  end
-
-  context "finalized config" do
-    context "sessions enabled" do
-      before do
-        config.sessions = :cookie, {secret: "abc"}
-        app_config.finalize!
-      end
-
-      it "is true" do
-        is_expected.to be true
-      end
-
-      context "explicitly disabled" do
-        before do
-          config.csrf_protection = false
-        end
-
-        it "is false" do
-          is_expected.to be false
-        end
-      end
-    end
-
-    context "sessions not enabled" do
-      before do
-        app_config.finalize!
-      end
-
-      it "is true" do
-        is_expected.to be false
-      end
-    end
-  end
-end

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

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config/actions"
-
-RSpec.describe Hanami::Config::Actions, "default values" do
-  let(:app_config) { Hanami::Config.new(app_name: "MyApp::App", env: :development) }
-  subject(:config) { app_config.actions }
-
-  describe "sessions" do
-    specify { expect(config.sessions).not_to be_enabled }
-  end
-
-  describe "name_inference_base" do
-    specify { expect(config.name_inference_base).to eq "actions" }
-  end
-
-  describe "view_name_inferrer" do
-    specify { expect(config.view_name_inferrer).to eq Hanami::Slice::ViewNameInferrer }
-  end
-
-  describe "view_name_inference_base" do
-    specify { expect(config.view_name_inference_base).to eq "views" }
-  end
-
-  describe "new default values applied to base action settings" do
-    describe "content_security_policy" do
-      specify { expect(config.content_security_policy).to be_kind_of(Hanami::Config::Actions::ContentSecurityPolicy) }
-    end
-
-    describe "default_headers" do
-      specify {
-        app_config.finalize!
-
-        expect(config.default_headers).to eq(
-          "X-Frame-Options" => "DENY",
-          "X-Content-Type-Options" => "nosniff",
-          "X-XSS-Protection" => "1; mode=block",
-          "Content-Security-Policy" => config.content_security_policy.to_s
-        )
-      }
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config/actions"
-
-RSpec.describe Hanami::Config::Actions, "#sessions" do
-  let(:config) { described_class.new }
-  subject(:sessions) { config.sessions }
-
-  context "no session config specified" do
-    it "is not enabled" do
-      expect(sessions).not_to be_enabled
-    end
-
-    it "returns nil storage" do
-      expect(sessions.storage).to be_nil
-    end
-
-    it "returns empty options" do
-      expect(sessions.options).to eq []
-    end
-
-    it "returns no session middleware" do
-      expect(sessions.middleware).to eq []
-    end
-  end
-
-  context "valid session config provided" do
-    before do
-      config.sessions = :cookie, {secret: "abc"}
-    end
-
-    it "is enabled" do
-      expect(sessions).to be_enabled
-    end
-
-    it "returns the given storage" do
-      expect(sessions.storage).to eq :cookie
-    end
-
-    it "returns the given options" do
-      expect(sessions.options).to eq [secret: "abc"]
-    end
-
-    it "returns an array of middleware classes and options" do
-      expect(sessions.middleware).to eq [Rack::Session::Cookie, {secret: "abc"}]
-    end
-  end
-end

data/spec/unit/hanami/config/actions_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-require "hanami/action"
-
-RSpec.describe Hanami::Config, "#actions" do
-  let(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::app" }
-
-  subject(:actions) { config.actions }
-
-  context "hanami-controller is bundled" do
-    it "is a full actions config" do
-      is_expected.to be_an_instance_of(Hanami::Config::Actions)
-
-      is_expected.to respond_to(:format)
-    end
-
-    it "configures base action settings" do
-      expect { actions.public_directory = "pub" }
-        .to change { actions.public_directory }
-        .to end_with("pub")
-    end
-
-    it "configures base actions settings using custom methods" do
-      expect { actions.formats.register(:json, "app/json") }
-        .to change { actions.formats.mapping }
-        .to include(json: have_attributes(media_type: "app/json"))
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-
-  context "hanami-controller is not bundled" do
-    before do
-      allow(Hanami).to receive(:bundled?).and_call_original
-      expect(Hanami).to receive(:bundled?).with("hanami-controller").and_return(false)
-    end
-
-    it "does not expose any settings" do
-      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
-      is_expected.not_to respond_to(:default_response_format)
-      is_expected.not_to respond_to(:default_response_format=)
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-end

data/spec/unit/hanami/config/base_url_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-require "uri"
-
-RSpec.describe Hanami::Config, "base_url" do
-  subject(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::app" }
-
-  it "defaults to a URI of 'http://0.0.0.0:2300'" do
-    expect(config.base_url).to eq URI("http://0.0.0.0:2300")
-  end
-
-  it "can be changed to another URI via a string" do
-    expect { config.base_url = "http://example.com" }
-      .to change { config.base_url }
-      .to(URI("http://example.com"))
-  end
-
-  it "can be changed to another URI object" do
-    expect { config.base_url = URI("http://example.com") }
-      .to change { config.base_url }
-      .to(URI("http://example.com"))
-  end
-end

data/spec/unit/hanami/config/console_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-
-RSpec.describe Hanami::Config, "#console" do
-  let(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::App" }
-
-  subject(:console) { config.console }
-
-  it "is a full console configuration" do
-    is_expected.to be_an_instance_of(Hanami::Config::Console)
-
-    is_expected.to respond_to(:engine)
-    is_expected.to respond_to(:include)
-    is_expected.to respond_to(:extensions)
-  end
-
-  it "can be finalized" do
-    is_expected.to respond_to(:finalize!)
-  end
-end

data/spec/unit/hanami/config/db_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-
-RSpec.describe Hanami::Config, "#db" do
-  let(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::App" }
-
-  subject(:db) { config.db }
-
-  context "hanami-router is bundled" do
-    it "is a full router configuration" do
-      is_expected.to be_an_instance_of(Hanami::Config::DB)
-
-      is_expected.to respond_to(:import_from_parent)
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-
-  context "hanami-db is 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 expose any settings" do
-      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
-      is_expected.not_to respond_to(:import_from_parent)
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-end

data/spec/unit/hanami/config/inflector_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-
-RSpec.describe Hanami::Config do
-  subject(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::app" }
-
-  describe "inflector" do
-    it "defaults to a Dry::Inflector instance" do
-      expect(config.inflector).to be_kind_of(Dry::Inflector)
-    end
-
-    it "can be replaced with another inflector" do
-      new_inflector = double(:inflector)
-
-      expect { config.inflector = new_inflector }
-        .to change { config.inflector }
-        .to new_inflector
-    end
-  end
-
-  describe "inflections" do
-    it "configures a new inflector with the given inflections" do
-      expect(config.inflector.pluralize("hanami")).to eq("hanamis")
-
-      config.inflections do |i|
-        i.uncountable("hanami")
-      end
-
-      expect(config.inflector).to be_kind_of(Dry::Inflector)
-      expect(config.inflector.pluralize("hanami")).to eq("hanami")
-    end
-  end
-end

data/spec/unit/hanami/config/logger_spec.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config/logger"
-require "hanami/slice_name"
-require "dry/inflector"
-require "logger"
-require "stringio"
-
-RSpec.describe Hanami::Config::Logger do
-  subject do
-    described_class.new(app_name: app_name, env: env)
-  end
-
-  let(:app_name) do
-    Hanami::SliceName.new(double(name: "MyApp::app"), inflector: -> { Dry::Inflector.new })
-  end
-
-  let(:env) { :development }
-
-  describe "#level" do
-    it "defaults to :debug" do
-      expect(subject.level).to eq(:debug)
-    end
-
-    context "when :production environment" do
-      let(:env) { :production }
-
-      it "returns :info" do
-        expect(subject.level).to eq(:info)
-      end
-    end
-  end
-
-  describe "#level=" do
-    it "a value" do
-      expect { subject.level = :warn }
-        .to change { subject.level }
-        .to(:warn)
-    end
-  end
-
-  describe "#stream" do
-    it "defaults to $stdout" do
-      expect(subject.stream).to eq($stdout)
-    end
-
-    context "when :test environment" do
-      let(:env) { :test }
-
-      it "returns a file" do
-        expected = File.join("log", "test.log")
-
-        expect(subject.stream).to eq(expected)
-      end
-    end
-  end
-
-  describe "#stream=" do
-    it "accepts a path to a file" do
-      expect { subject.stream = File::NULL }
-        .to change { subject.stream }
-        .to(File::NULL)
-    end
-
-    it "accepts a IO object" do
-      stream = StringIO.new
-
-      expect { subject.stream = stream }
-        .to change { subject.stream }
-        .to(stream)
-    end
-  end
-
-  describe "#formatter" do
-    it "defaults to :string" do
-      expect(subject.formatter).to eq(:string)
-    end
-
-    context "when :production environment" do
-      let(:env) { :production }
-
-      it "returns :json" do
-        expect(subject.formatter).to eq(:json)
-      end
-    end
-  end
-
-  describe "#formatter=" do
-    it "accepts a formatter" do
-      expect { subject.formatter = :json }
-        .to change { subject.formatter }
-        .to(:json)
-    end
-  end
-
-  describe "#template" do
-    it "defaults to :details" do
-      expect(subject.template).to be(:details)
-    end
-  end
-
-  describe "#template=" do
-    it "accepts a value" do
-      expect { subject.template = "%<message>s" }
-        .to change { subject.template }
-        .to("%<message>s")
-    end
-  end
-
-  describe "#filters" do
-    it "defaults to a standard array of sensitive param names" do
-      expect(subject.filters).to include(*%w[_csrf password password_confirmation])
-    end
-
-    it "can have other params names added" do
-      expect { subject.filters << "secret" }
-        .to change { subject.filters }
-        .to array_including("secret")
-
-      expect { subject.filters += ["yet", "another"] }
-        .to change { subject.filters }
-        .to array_including(["yet", "another"])
-    end
-
-    it "can be changed to another array" do
-      expect { subject.filters = ["secret"] }
-        .to change { subject.filters }
-        .to ["secret"]
-    end
-  end
-
-  describe "#options" do
-    it "defaults to empty hash" do
-      expect(subject.options).to eq({})
-    end
-  end
-
-  describe "#options=" do
-    it "accepts value" do
-      subject.options = expected = {rotate: "daily"}
-
-      expect(subject.options).to eq(expected)
-    end
-  end
-end
-
-RSpec.describe Hanami::Config do
-  subject(:config) { described_class.new(app_name: app_name, env: env) }
-
-  let(:app_name) do
-    Hanami::SliceName.new(double(name: "SOS::app"), inflector: -> { Dry::Inflector.new })
-  end
-
-  let(:env) { :development }
-
-  describe "#logger" do
-    before do
-      config.inflections do |inflections|
-        inflections.acronym "SOS"
-      end
-
-      config.logger.finalize!
-    end
-
-    describe "#app_name" do
-      it "defaults to Hanami::Config#app_name" do
-        expect(config.logger.app_name).to eq(config.app_name)
-      end
-    end
-  end
-
-  describe "#logger_instance" do
-    it "defaults to using Dry::Logger, based on the default logger settings" do
-      expect(config.logger_instance).to be_a(Dry::Logger::Dispatcher)
-      expect(config.logger_instance.level).to eq Logger::DEBUG
-    end
-
-    it "can be changed to a pre-initialized instance via #logger=" do
-      logger_instance = Object.new
-
-      expect { config.logger = logger_instance }
-        .to change { config.logger_instance }
-        .to logger_instance
-    end
-
-    context "unrecognized :env" do
-      let(:env) { :staging }
-
-      it "provides a fail-safe configuration" do
-        expect { config.logger_instance }.to_not raise_error
-        expect(config.logger_instance).to be_a(Dry::Logger::Dispatcher)
-      end
-    end
-  end
-end

data/spec/unit/hanami/config/render_detailed_errors_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/inflector"
-
-RSpec.describe Hanami::Config, "#render_detailed_errors" do
-  let(:config) { described_class.new(app_name: app_name, env: env) }
-  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::App"), inflector: Dry::Inflector.new) }
-
-  subject(:render_detailed_errors) { config.render_detailed_errors }
-
-  context "development mode" do
-    let(:env) { :development }
-    it { is_expected.to be true }
-  end
-
-  context "test mode" do
-    let(:env) { :test }
-    it { is_expected.to be false }
-  end
-
-  context "production mode" do
-    let(:env) { :production }
-    it { is_expected.to be false }
-  end
-end

data/spec/unit/hanami/config/render_errors_spec.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/inflector"
-
-RSpec.describe Hanami::Config, "#render_errors" do
-  let(:config) { described_class.new(app_name: app_name, env: env) }
-  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::App"), inflector: Dry::Inflector.new) }
-
-  subject(:render_errors) { config.render_errors }
-
-  context "development mode" do
-    let(:env) { :development }
-    it { is_expected.to be false }
-  end
-
-  context "test mode" do
-    let(:env) { :test }
-    it { is_expected.to be false }
-  end
-
-  context "production mode" do
-    let(:env) { :production }
-    it { is_expected.to be true }
-  end
-end

data/spec/unit/hanami/config/router_spec.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/config"
-
-RSpec.describe Hanami::Config, "#router" do
-  let(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { "MyApp::app" }
-
-  subject(:router) { config.router }
-
-  context "hanami-router is bundled" do
-    it "is a full router configuration" do
-      is_expected.to be_an_instance_of(Hanami::Config::Router)
-
-      is_expected.to respond_to(:resolver)
-    end
-
-    it "loads the middleware stack" do
-      subject
-
-      expect(config.middleware_stack).not_to be_nil
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-
-  context "hanami-router is not bundled" do
-    before do
-      allow(Hanami).to receive(:bundled?).and_call_original
-      allow(Hanami).to receive(:bundled?).with("hanami-router").and_return(false)
-    end
-
-    it "does not expose any settings" do
-      is_expected.to be_an_instance_of(Hanami::Config::NullConfig)
-      is_expected.not_to respond_to(:resolver)
-    end
-
-    it "can be finalized" do
-      is_expected.to respond_to(:finalize!)
-    end
-  end
-end

data/spec/unit/hanami/config/slices_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/inflector"
-require "hanami/config"
-require "hanami/slice_name"
-
-RSpec.describe Hanami::Config, "#slices" do
-  subject(:config) { described_class.new(app_name: app_name, env: :development) }
-  let(:app_name) { Hanami::SliceName.new(double(name: "MyApp::App"), inflector: Dry::Inflector.new) }
-
-  subject(:slices) { config.slices }
-
-  before do
-    @orig_env = ENV.to_h
-  end
-
-  after do
-    ENV.replace(@orig_env)
-  end
-
-  it "is nil by default" do
-    is_expected.to be nil
-  end
-
-  it "defaults to the HANAMI_LOAD_SLICES env var, separated by commas" do
-    ENV["HANAMI_SLICES"] = "main,admin"
-    is_expected.to eq %w[main admin]
-  end
-
-  it "strips spaces from HANAMI_LOAD_SLICES env var entries" do
-    ENV["HANAMI_SLICES"] = "main, admin"
-    is_expected.to eq %w[main admin]
-  end
-end