hanami 2.3.2 → 3.0.0

data/spec/unit/hanami/port_spec.rb

@@ -1,117 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/port"
-
-RSpec.describe Hanami::Port do
-  context "Hanami::Port::DEFAULT" do
-    it "returns default value" do
-      expect(Hanami::Port::DEFAULT).to eq(2300)
-    end
-  end
-
-  context "Hanami::Port::ENV_VAR" do
-    it "returns default value" do
-      expect(Hanami::Port::ENV_VAR).to eq("HANAMI_PORT")
-    end
-  end
-
-  context ".call" do
-    let(:value) { nil }
-    let(:env) { nil }
-
-    it "is aliased as .[]" do
-      expect(described_class[value, env]).to be(2300)
-    end
-
-    context "when ENV var is nil" do
-      context "and value is nil" do
-        it "returns default value" do
-          expect(described_class.call(value, env)).to be(2300)
-        end
-      end
-
-      context "and value is not nil" do
-        let(:value) { 18_000 }
-
-        it "returns given value" do
-          expect(described_class.call(value, env)).to be(value)
-        end
-
-        context "and value is default" do
-          let(:value) { 2300 }
-
-          it "returns given value" do
-            expect(described_class.call(value, env)).to be(value)
-          end
-        end
-      end
-    end
-
-    context "when ENV var not nil" do
-      let(:env) { 9000 }
-
-      context "and value is nil" do
-        it "returns env value" do
-          expect(described_class.call(value, env)).to be(env)
-        end
-      end
-
-      context "and value is not nil" do
-        let(:value) { 18_000 }
-
-        it "returns given value" do
-          expect(described_class.call(value, env)).to be(value)
-        end
-
-        context "and value is default" do
-          let(:value) { 2300 }
-
-          it "returns env value" do
-            expect(described_class.call(value, env)).to be(env)
-          end
-        end
-      end
-    end
-  end
-
-  context ".call!" do
-    before { ENV.delete("HANAMI_PORT") }
-    let(:value) { 2300 }
-
-    context "when given value is default" do
-      it "doesn't set env var" do
-        described_class.call!(value)
-
-        expect(ENV.key?("HANAMI_PORT")).to be(false)
-      end
-    end
-
-    context "when given value isn't default" do
-      let(:value) { 9000 }
-
-      it "set env var" do
-        described_class.call!(value)
-
-        expect(ENV.fetch("HANAMI_PORT")).to eq(value.to_s)
-      end
-    end
-  end
-
-  context ".default?" do
-    context "when given value is default" do
-      let(:value) { 2300 }
-
-      it "returns true" do
-        expect(described_class.default?(value)).to be(true)
-      end
-    end
-
-    context "when given value isn't default" do
-      let(:value) { 9000 }
-
-      it "returns false" do
-        expect(described_class.default?(value)).to be(false)
-      end
-    end
-  end
-end

data/spec/unit/hanami/providers/db/config/default_config_spec.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system"
-require "hanami/providers/db"
-
-RSpec.describe "Hanami::Providers::DB / Config / Default config", :app_integration do
-  subject(:config) { provider.source.config }
-
-  let(:provider) {
-    Hanami.app.prepare
-    Hanami.app.configure_provider(:db)
-    Hanami.app.container.providers[:db]
-  }
-
-  before do
-    module TestApp
-      class App < Hanami::App
-      end
-    end
-  end
-
-  specify %(relations_path = "relations") do
-    expect(config)
-  end
-
-  describe "sql adapter" do
-    before do
-      skip_defaults if respond_to?(:skip_defaults)
-      config.adapter(:sql).configure_for_database("mysql://localhost/test_app_development")
-    end
-
-    describe "plugins" do
-      specify do
-        expect(config.adapter(:sql).plugins).to match [
-          [{relations: :instrumentation}, instance_of(Proc)],
-          [{relations: :auto_restrictions}, nil],
-        ]
-      end
-
-      describe "skipping defaults" do
-        def skip_defaults
-          config.adapter(:sql).skip_defaults :plugins
-        end
-
-        it "configures no plugins" do
-          expect(config.adapter(:sql).plugins).to eq []
-        end
-      end
-    end
-
-    describe "extensions" do
-      specify do
-        expect(config.adapter(:sql).extensions).to eq [
-          :caller_logging,
-          :error_sql,
-          :sql_comments
-        ]
-      end
-
-      describe "skipping defaults" do
-        def skip_defaults
-          config.adapter(:sql).skip_defaults :extensions
-        end
-
-        it "configures no extensions" do
-          expect(config.adapter(:sql).extensions).to eq []
-        end
-      end
-    end
-
-    describe "skipping all defaults" do
-      def skip_defaults
-        config.adapter(:sql).skip_defaults
-      end
-
-      it "configures no plugins or extensions" do
-        expect(config.adapter(:sql).plugins).to eq []
-        expect(config.adapter(:sql).extensions).to eq []
-      end
-    end
-  end
-
-  describe "sql adapter for postgres" do
-    before do
-      config.adapter(:sql).configure_for_database("postgresql://localhost/test_app_development")
-    end
-
-    specify "extensions" do
-      expect(config.adapters[:sql].extensions).to eq [
-        :caller_logging,
-        :error_sql,
-        :sql_comments,
-        :pg_array,
-        :pg_enum,
-        :pg_json,
-        :pg_range
-      ]
-    end
-  end
-end

data/spec/unit/hanami/providers/db/config/gateway_spec.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system"
-require "hanami/providers/db"
-
-RSpec.describe "Hanami::Providers::DB / Config / Gateway config", :app_integration do
-  subject(:config) { provider.source.config }
-
-  let(:provider) {
-    Hanami.app.prepare
-    Hanami.app.configure_provider(:db)
-    Hanami.app.container.providers[:db]
-  }
-
-  before do
-    module TestApp
-      class App < Hanami::App
-      end
-    end
-  end
-
-  describe "sql adapter" do
-    before do
-      config.adapter(:sql).configure_for_database("sqlite::memory")
-    end
-
-    describe "connection_options" do
-      let(:default) { config.gateway(:default) }
-
-      it "merges kwargs into connection_options configuration" do
-        expect { default.connection_options(timeout: 10_000) }
-          .to change { default.connection_options }.from({}).to({timeout: 10_000})
-      end
-
-      it "sets options per-gateway" do
-        other = config.gateway(:other)
-        expect { default.connection_options(timeout: 10_000) }
-          .to_not change { other.connection_options }
-      end
-
-      it "is reflected in Gateway#cache_keys" do
-        default.adapter(:sql) {}
-        expect { default.connection_options(timeout: 10_000) }
-          .to change { default.cache_keys }
-      end
-    end
-
-    describe "options" do
-      it "combines connection_options with adapter.gateway_options" do
-        config.gateway :default do |gw|
-          gw.connection_options foo: "bar"
-
-          gw.adapter :sql do |a|
-            a.skip_defaults
-            a.extension :baz, :quux
-          end
-        end
-
-        expect(config.gateway(:default).options)
-          .to include(foo: "bar", extensions: [:baz, :quux])
-      end
-
-      it "ignores conflicting keys from connection_options" do
-        config.gateway :default do |gw|
-          gw.connection_options extensions: "foo"
-          gw.adapter(:sql) { _1.skip_defaults }
-        end
-
-        expect(config.gateway(:default).options).to eq({extensions: []})
-      end
-    end
-  end
-end

data/spec/unit/hanami/providers/db/config_spec.rb

@@ -1,143 +0,0 @@
-# frozen_string_literal: true
-
-require "dry/system"
-require "hanami/providers/db"
-
-RSpec.describe "Hanami::Providers::DB.config", :app_integration do
-  subject(:config) { provider.source.config }
-
-  let(:provider) {
-    Hanami.app.prepare
-    Hanami.app.configure_provider(:db)
-    Hanami.app.container.providers[:db]
-  }
-
-  before do
-    module TestApp
-      class App < Hanami::App
-      end
-    end
-  end
-
-  describe "#adapter" do
-    it "adds an adapter" do
-      expect { config.adapter(:yaml) }
-        .to change { config.adapters.to_h }
-        .to hash_including(:yaml)
-    end
-
-    it "yields the adapter for configuration" do
-      expect { |b| config.adapter(:yaml, &b) }
-        .to yield_with_args(an_instance_of(Hanami::Providers::DB::Adapter))
-    end
-  end
-
-  describe "adapters" do
-    subject(:adapter) { config.adapter(:yaml) }
-
-    describe "#plugin" do
-      it "adds a plugin without a block" do
-        expect { adapter.plugin relations: :foo }
-          .to change { adapter.plugins }
-          .to [[{relations: :foo}, nil]]
-      end
-
-      it "adds a plugin with a block" do
-        block = -> plugin_config { }
-
-        expect {
-          adapter.plugin(relations: :foo, &block)
-        }
-          .to change { adapter.plugins }
-          .to [[{relations: :foo}, block]]
-      end
-    end
-
-    describe "#plugins" do
-      it "can be cleared" do
-        adapter.plugin relations: :foo
-
-        expect { adapter.plugins.clear }
-          .to change { adapter.plugins }
-          .to []
-      end
-    end
-
-    describe "#gateway_cache_keys" do
-      it "includes the configured extensions" do
-        expect(adapter.gateway_cache_keys).to eq({})
-      end
-    end
-
-    describe "#gateway_options" do
-      specify do
-        expect(adapter.gateway_options).to eq({})
-      end
-    end
-
-    describe "#clear" do
-      it "clears previously configured plugins" do
-        adapter.plugin relations: :foo
-
-        expect { adapter.clear }.to change { adapter.plugins }.to([])
-      end
-    end
-
-    describe ":sql adapter" do
-      subject(:adapter) { config.adapter(:sql) }
-
-      describe "#extension" do
-        it "adds an extension" do
-          adapter.clear
-          expect { adapter.extension :foo }
-            .to change { adapter.extensions }
-            .to [:foo]
-        end
-
-        it "adds multiple extensions" do
-          adapter.clear
-          expect { adapter.extension :foo, :bar }
-            .to change { adapter.extensions }
-            .to [:foo, :bar]
-        end
-      end
-
-      describe "#extensions" do
-        it "can be cleareed" do
-          adapter.extension :foo
-
-          expect { adapter.extensions.clear }
-            .to change { adapter.extensions }
-            .to []
-        end
-      end
-
-      describe "#gateway_cache_keys" do
-        it "includes the configured extensions" do
-          adapter.clear
-          adapter.extension :foo, :bar
-          expect(adapter.gateway_cache_keys).to eq(extensions: [:foo, :bar])
-        end
-      end
-
-      describe "#gateway_options" do
-        it "includes the configured extensions" do
-          adapter.clear
-          adapter.extension :foo, :bar
-          expect(adapter.gateway_options).to eq(extensions: [:foo, :bar])
-        end
-      end
-
-      describe "#clear" do
-        it "clears previously configured plugins and extensions" do
-          adapter.plugin relations: :foo
-          adapter.extension :foo
-
-          expect { adapter.clear }
-            .to change { adapter.plugins }.to([])
-            .and change { adapter.extensions }.to([])
-        end
-      end
-    end
-  end
-end

data/spec/unit/hanami/router/errors/not_allowed_error_spec.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/router"
-require "hanami/extensions/router/errors"
-
-RSpec.describe(Hanami::Router::NotAllowedError) do
-  subject(:error) { described_class.new(env, allowed_methods) }
-
-  let(:env) { Rack::MockRequest.env_for("http://example.com/example", method: "POST") }
-  let(:allowed_methods) { ["GET", "HEAD"] }
-
-  it "is a Hanami::Router::Error" do
-    expect(error.class).to be < Hanami::Router::Error
-  end
-
-  it "returns a relevant message" do
-    expect(error.to_s).to eq "Only GET, HEAD requests are allowed at /example"
-  end
-
-  it "returns the env" do
-    expect(error.env).to be env
-  end
-
-  it "returns the allowed methods" do
-    expect(error.allowed_methods).to be allowed_methods
-  end
-end

data/spec/unit/hanami/router/errors/not_found_error_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/router"
-require "hanami/extensions/router/errors"
-
-RSpec.describe(Hanami::Router::NotFoundError) do
-  subject(:error) { described_class.new(env) }
-
-  let(:env) { Rack::MockRequest.env_for("http://example.com/example", method: "GET") }
-
-  it "is a Hanami::Router::Error" do
-    expect(error.class).to be < Hanami::Router::Error
-  end
-
-  it "returns a relevant message" do
-    expect(error.to_s).to eq "No route found for GET /example"
-  end
-
-  it "returns the env" do
-    expect(error.env).to be env
-  end
-end

data/spec/unit/hanami/settings/env_store_spec.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/settings/env_store"
-
-RSpec.describe Hanami::Settings::EnvStore do
-  it "defaults to using ENV as the store" do
-    orig_env = ENV.to_h
-
-    ENV["FOO"] = "bar"
-    expect(described_class.new.fetch("FOO")).to eq "bar"
-
-    ENV.replace(orig_env)
-  end
-
-  describe "#fetch" do
-    it "fetches from ENV" do
-      store = described_class.new(store: {"FOO" => "bar"})
-
-      expect(store.fetch("FOO")).to eq("bar")
-    end
-
-    it "capitalizes name" do
-      store = described_class.new(store: {"FOO" => "bar"})
-
-      expect(store.fetch("foo")).to eq("bar")
-    end
-
-    it "coerces name to string" do
-      store = described_class.new(store: {"FOO" => "bar"})
-
-      expect(store.fetch(:foo)).to eq("bar")
-    end
-
-    it "returns default when value is not found" do
-      store = described_class.new(store: {"FOO" => "bar"})
-
-      expect(store.fetch("BAZ", "qux")).to eq("qux")
-    end
-
-    it "returns the block execution when value is not found" do
-      store = described_class.new(store: {"FOO" => "bar"})
-
-      expect(store.fetch("BAZ") { "qux" }).to eq("qux") # rubocop:disable Style/RedundantFetchBlock
-    end
-
-    it "raises KeyError when value is not found and no default is given" do
-      store = described_class.new(store: {"FOO" => "bar"})
-
-      expect { store.fetch("BAZ") }.to raise_error(KeyError)
-    end
-  end
-end

data/spec/unit/hanami/settings_spec.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require "hanami/settings"
-
-RSpec.describe Hanami::Settings do
-  describe "#initialize" do
-    it "uses values from the store when present" do
-      settings_class = Class.new(described_class) do
-        setting :database_url, default: "postgres://localhost/test_app_development"
-      end
-
-      store = {database_url: "mysql://localhost/test_app_development"}.freeze
-
-      instance = settings_class.new(store)
-
-      expect(instance.config.database_url).to eq("mysql://localhost/test_app_development")
-    end
-
-    it "uses defaults when values are not present in the store" do
-      settings_class = Class.new(described_class) do
-        setting :database_url, default: "postgres://localhost/test_app_development"
-      end
-
-      store = {}.freeze
-
-      instance = settings_class.new(store)
-
-      expect(instance.config.database_url).to eq("postgres://localhost/test_app_development")
-    end
-
-    it "collects error for all setting values failing their constructors" do
-      settings_class = Class.new(described_class) do
-        setting :database_url, constructor: ->(_v) { raise "nope to database" }
-        setting :redis_url, constructor: ->(_v) { raise "nope to redis" }
-      end
-
-      store = {
-        database_url: "postgres://localhost/test_app_development",
-        redis_url: "redis://localhost:6379"
-      }.freeze
-
-      expect { settings_class.new(store) }.to raise_error(
-        described_class::InvalidSettingsError,
-        /(database_url: nope to database).*(redis_url: nope to redis)/m,
-      )
-    end
-
-    it "collects errors for missing settings failing their constructors" do
-      settings_class = Class.new(described_class) do
-        setting :database_url, constructor: ->(_v) { raise "nope to database" }
-      end
-
-      store = {}
-
-      expect { settings_class.new(store) }.to raise_error(
-        described_class::InvalidSettingsError,
-        /database_url: nope to database/m,
-      )
-    end
-
-    it "finalizes the config" do
-      settings_class = Class.new(described_class) do
-        setting :database_url
-      end
-
-      store = {database_url: "postgres://localhost/test_app_development"}
-
-      settings = settings_class.new(store)
-
-      expect(settings.config).to be_frozen
-      expect { settings.database_url = "new" }.to raise_error(Dry::Configurable::FrozenConfigError)
-    end
-  end
-
-  describe "#inspect" do
-    it "shows keys" do
-      settings_class = Class.new(described_class) do
-        setting :password, default: "dont_tell_anybody"
-        setting :passphrase, default: "shhhh"
-      end
-
-      expect(settings_class.new.inspect).to eq(
-        "#<#{settings_class.to_s} [password, passphrase]>"
-      )
-    end
-  end
-
-  describe "#inspect_values" do
-    it "shows keys & values" do
-      settings_class = Class.new(described_class) do
-        setting :password, default: "dont_tell_anybody"
-        setting :passphrase, default: "shhh"
-      end
-
-      expect(settings_class.new.inspect_values).to eq(
-        "#<#{settings_class.to_s} password=\"dont_tell_anybody\" passphrase=\"shhh\">"
-      )
-    end
-  end
-
-  it "delegates unknown methods to config" do
-    settings_class = Class.new(described_class) do
-      setting :foo, default: "bar"
-    end
-    store = {}.freeze
-
-    instance = settings_class.new(store)
-
-    expect(instance.foo).to eq("bar")
-  end
-end