hanami 2.0.0.alpha8 → 2.0.0.beta1

data/spec/unit/hanami/configuration/views_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "hanami/configuration"
+require "hanami/configuration/views"
+require "saharspec/matchers/dont"
+
+RSpec.describe Hanami::Configuration, "#views" do
+  let(:configuration) { described_class.new(app_name: app_name, env: :development) }
+  let(:app_name) { "MyApp::app" }
+
+  subject(:views) { configuration.views }
+
+  context "Hanami::View available" do
+    it "exposes Hanami::Views's app configuration" do
+      is_expected.to be_an_instance_of(Hanami::Configuration::Views)
+
+      is_expected.to respond_to(:finalize!)
+      is_expected.to respond_to(:layouts_dir)
+      is_expected.to respond_to(:layouts_dir=)
+    end
+
+    it "includes base view configuration" do
+      expect(views).to respond_to(:paths)
+      expect(views).to respond_to(:paths=)
+    end
+
+    it "does not include the inflector setting" do
+      expect(views).not_to respond_to(:inflector)
+      expect(views).not_to respond_to(:inflector=)
+    end
+
+    describe "#settings" do
+      it "includes locally defined settings" do
+        expect(views.settings).to include :parts_path
+      end
+
+      it "includes all view settings apart from inflector" do
+        expect(views.settings).to include (Hanami::View.settings - [:inflector])
+      end
+    end
+
+    it "preserves default values from the base view configuration" do
+      expect(views.layouts_dir).to eq Hanami::View.config.layouts_dir
+    end
+
+    it "allows settings to be configured independently of the base view configuration" do
+      expect { views.layouts_dir = "custom_layouts" }
+        .to change { views.layouts_dir }.to("custom_layouts")
+        .and(dont.change { Hanami::View.config.layouts_dir })
+    end
+
+    describe "specialised default values" do
+      describe "paths" do
+        it 'is ["templates"]' do
+          expect(views.paths).to match [
+            an_object_satisfying { |path| path.dir.to_s == "templates" }
+          ]
+        end
+      end
+
+      describe "template_inference_base" do
+        it 'is "views"' do
+          expect(views.template_inference_base).to eq "views"
+        end
+      end
+
+      describe "layout" do
+        it 'is "app"' do
+          expect(views.layout).to eq "app"
+        end
+      end
+    end
+
+    describe "finalized configuration" do
+      before do
+        views.finalize!
+      end
+
+      it "is frozen" do
+        expect(views).to be_frozen
+      end
+
+      it "does not allow changes to locally defined settings" do
+        expect { views.parts_path = "parts" }.to raise_error(Dry::Configurable::FrozenConfig)
+      end
+
+      it "does not allow changes to base view settings" do
+        expect { views.paths = [] }.to raise_error(Dry::Configurable::FrozenConfig)
+      end
+    end
+  end
+
+  context "Hanami::View not available" do
+    before do
+      load_error = LoadError.new.tap do |error|
+        error.instance_variable_set :@path, "hanami/view"
+      end
+
+      allow_any_instance_of(described_class)
+        .to receive(:require)
+        .with(anything)
+        .and_call_original
+
+      allow_any_instance_of(described_class)
+        .to receive(:require)
+        .with("hanami/view")
+        .and_raise load_error
+    end
+
+    it "does not expose any settings" do
+      is_expected.not_to be_an_instance_of(Hanami::Configuration::Views)
+      is_expected.not_to respond_to(:layouts_dir)
+      is_expected.not_to respond_to(:layouts_dir=)
+    end
+
+    it "can be finalized" do
+      is_expected.to respond_to(:finalize!)
+    end
+  end
+end

data/spec/unit/hanami/configuration_spec.rb

@@ -0,0 +1,43 @@
+require "hanami/configuration"
+
+RSpec.describe Hanami::Configuration do
+  let(:config) { described_class.new(app_name: app_name, env: env) }
+  let(:app_name) { "MyApp::app" }
+  let(:env) { :development }
+
+  describe "environment-specific configuration" do
+    before do
+      config.logger.level = :debug__set_without_env
+    end
+
+    before do
+      config.environment :production do |c|
+        c.logger.level = :info__set_for_production_env
+      end
+    end
+
+    context "settings configured for current env" do
+      let(:env) { :production }
+
+      it "applies the settings" do
+        expect(config.logger.level).to eq :info__set_for_production_env
+      end
+
+      it "leaves the settings in place when finalizing" do
+        expect { config.finalize! }.not_to(change { config.logger.level })
+      end
+    end
+
+    context "settings configured for a different env" do
+      let(:env) { :development }
+
+      it "does not apply the settings" do
+        expect(config.logger.level).to eq :debug__set_without_env
+      end
+
+      it "does not apply the settings when finalizing" do
+        expect { config.finalize! }.not_to(change { config.logger.level })
+      end
+    end
+  end
+end

data/spec/unit/hanami/env_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+RSpec.describe Hanami, ".env" do
+  subject(:env) { described_class.env }
+
+  before do
+    @orig_env = ENV.to_h
+  end
+
+  after do
+    ENV.replace(@orig_env)
+  end
+
+  context "HANAMI_ENV in ENV" do
+    before do
+      ENV["HANAMI_ENV"] = "test"
+    end
+
+    it "is the value of HANAMI_ENV" do
+      is_expected.to eq :test
+    end
+  end
+
+  context "RACK_ENV in ENV" do
+    before do
+      ENV["RACK_ENV"] = "test"
+    end
+
+    it "is the value of RACK_ENV" do
+      is_expected.to eq :test
+    end
+  end
+
+  context "both HANAMI_ENV and RACK_ENV in ENV" do
+    before do
+      ENV["HANAMI_ENV"] = "test"
+      ENV["RACK_ENV"] = "production"
+    end
+
+    it "is the value of HANAMI_ENV" do
+      is_expected.to eq :test
+    end
+  end
+
+  context "no ENV vars set" do
+    before do
+      ENV.delete("HANAMI_ENV")
+    end
+
+    it "defaults to \"development\"" do
+      is_expected.to eq :development
+    end
+  end
+end

data/spec/unit/hanami/routes_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "hanami/routes"
+
+RSpec.describe Hanami::Routes do
+  describe ".define" do
+    it "sets routes block" do
+      routes_class = Class.new(described_class)
+
+      routes_class.define { "Dummy routes" }
+
+      expect(routes_class.routes.call).to eq("Dummy routes")
+    end
+  end
+
+  describe ".routes" do
+    context "when called before the routes have been defined" do
+      it "raises an error" do
+        routes_class = Class.new(described_class)
+
+        expect { routes_class.routes }.to raise_error(RuntimeError)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "hanami/settings/dotenv_store"
+require "dotenv"
+
+RSpec.describe Hanami::Settings::DotenvStore do
+  def mock_dotenv(store)
+    dotenv = spy(:dotenv)
+    allow(store).to receive(:require).and_call_original
+    stub_const "Dotenv", dotenv
+  end
+
+  describe "#with_dotenv_loaded" do
+    context "dotenv available and environment other than test" do
+      it "requires and loads a range of dotenv files, specific to the current environment" do
+        store = described_class.new(store: {}, hanami_env: :development)
+        dotenv = mock_dotenv(store)
+
+        store.with_dotenv_loaded
+
+        expect(store).to have_received(:require).with("dotenv").ordered
+        expect(dotenv).to have_received(:load).ordered.with(
+          ".env.development.local",
+          ".env.local",
+          ".env.development",
+          ".env"
+        )
+      end
+
+      it "returns self" do
+        store = described_class.new(store: {}, hanami_env: :development)
+
+        expect(store.with_dotenv_loaded).to be(store)
+      end
+    end
+
+    context "dotenv available and test environment" do
+      it "does not load .env.local (which is intended for non-test settings only)" do
+        store = described_class.new(store: {}, hanami_env: :test)
+        dotenv = mock_dotenv(store)
+
+        store.with_dotenv_loaded
+
+        expect(store).to have_received(:require).with("dotenv").ordered
+        expect(dotenv).to have_received(:load).ordered.with(
+          ".env.test.local",
+          ".env.test",
+          ".env"
+        )
+      end
+
+      it "returns self" do
+        store = described_class.new(store: {}, hanami_env: :test)
+
+        expect(store.with_dotenv_loaded).to be(store)
+      end
+    end
+
+    context "dotenv unavailable" do
+      let(:store) { described_class.new(store: {}) }
+
+      before do
+        allow(store).to receive(:require).with("dotenv").and_raise LoadError
+      end
+
+      it "attempts to require dotenv" do
+        store.with_dotenv_loaded
+
+        expect(store).to have_received(:require).with("dotenv")
+      end
+
+      it "gracefully ignores load errors" do
+        expect { store.with_dotenv_loaded }.not_to raise_error
+      end
+
+      it "returns self" do
+        expect(store.with_dotenv_loaded).to be(store)
+      end
+    end
+  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")
+    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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "hanami/settings"
+
+RSpec.describe Hanami::Settings do
+  describe "#initialize" do
+    it "uses values from the store when present" do
+      config_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 = config_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
+      config_class = Class.new(described_class) do
+        setting :database_url, default: "postgres://localhost/test_app_development"
+      end
+      store = {}.freeze
+
+      instance = config_class.new(store)
+
+      expect(instance.config.database_url).to eq("postgres://localhost/test_app_development")
+    end
+
+    it "collects error for all failed settings" do
+      config_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 { config_class.new(store) }.to raise_error(
+        described_class::InvalidSettingsError,
+        /(database_url: nope to database).*(redis_url: nope to redis)/m,
+      )
+    end
+  end
+
+  it "delegates unknown methods to config" do
+    config_class = Class.new(described_class) do
+      setting :foo, default: "bar"
+    end
+    store = {}.freeze
+
+    instance = config_class.new(store)
+
+    expect(instance.foo).to eq("bar")
+  end
+end

data/spec/unit/hanami/slice_configurable_spec.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "hanami/app"
+require "hanami/slice_configurable"
+
+RSpec.describe Hanami::SliceConfigurable, :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+        register_slice :main
+        register_slice :admin
+      end
+
+      class BaseClass
+        extend Hanami::SliceConfigurable
+
+        def self.configure_for_slice(slice)
+          traces << slice
+        end
+
+        def self.traces
+          @traces ||= []
+        end
+
+        def self.inherited(subclass)
+          subclass.instance_variable_set(:@traces, traces.dup)
+          super
+        end
+      end
+    end
+
+    Hanami.app.prepare
+  end
+
+  context "subclass inside slice namespace" do
+    before do
+      module Main
+        class MySubclass < TestApp::BaseClass; end
+      end
+    end
+
+    subject(:subclass) { Main::MySubclass }
+
+    it "calls `configure_for_slice` with the slice" do
+      expect(subclass.traces).to eq [Main::Slice]
+    end
+
+    context "further subclass, within same slice" do
+      before do
+        module Main
+          class MySubSubclass < Main::MySubclass; end
+        end
+      end
+
+      subject(:subclass) { Main::MySubSubclass }
+
+      it "calls `configure_for_slice` again for the same slice" do
+        expect(subclass.traces).to eq [Main::Slice, Main::Slice]
+      end
+    end
+
+    context "further subclass, within another slice namespace" do
+      before do
+        module Admin
+          class MySubSubclass < Main::MySubclass; end
+        end
+      end
+
+      subject(:subclass) { Admin::MySubSubclass }
+
+      it "calls `configure_for_slice` with the other slice" do
+        expect(subclass.traces).to eq [Main::Slice, Admin::Slice]
+      end
+    end
+  end
+
+  context "class inside app" do
+    before do
+      module TestApp
+        class MySubclass < TestApp::BaseClass; end
+      end
+    end
+
+    subject(:subclass) { TestApp::MySubclass }
+
+    it "calls `configure_for_slice` with the app instance" do
+      expect(subclass.traces).to eq [TestApp::App]
+    end
+
+    context "further subclass, within another slice namespace" do
+      before do
+        module Main
+          class MySubSubclass < TestApp::MySubclass; end
+        end
+      end
+
+      subject(:subclass) { Main::MySubSubclass }
+
+      it "calls `configure_for_slice` with the other slice" do
+        expect(subclass.traces).to eq [TestApp::App, Main::Slice]
+      end
+    end
+  end
+end

data/spec/unit/hanami/slice_name_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "hanami/slice_name"
+
+require "dry/inflector"
+
+RSpec.describe Hanami::SliceName do
+  subject(:slice_name) { described_class.new(slice, inflector: -> { inflector }) }
+  let(:slice) { double(name: "Main::Slice") }
+  let(:inflector) { Dry::Inflector.new }
+
+  let(:slice_module) { Module.new }
+
+  before do
+    stub_const "Main", slice_module
+  end
+
+  describe "#name" do
+    it "returns the downcased, underscored string name of the module containing the slice" do
+      expect(slice_name.name).to eq "main"
+    end
+  end
+
+  describe "#to_s" do
+    it "returns the downcased, underscored string name of the module containing the slice" do
+      expect(slice_name.to_s).to eq "main"
+    end
+  end
+
+  describe "#to_sym" do
+    it "returns the downcased, underscored, symbolized name of the module containing the slice" do
+      expect(slice_name.to_sym).to eq :main
+    end
+  end
+
+  describe "#namespace_name" do
+    it "returns the string name of the module containing the slice" do
+      expect(slice_name.namespace_name).to eq "Main"
+    end
+  end
+
+  describe "#namespace_const" do
+    it "returns the module containing the slice" do
+      expect(slice_name.namespace).to be slice_module
+    end
+  end
+end

data/spec/unit/hanami/slice_spec.rb

@@ -0,0 +1,17 @@
+require "hanami/slice"
+
+RSpec.describe Hanami::Slice, :app_integration do
+  before do
+    module TestApp
+      class App < Hanami::App
+      end
+    end
+  end
+
+  describe ".prepare" do
+    it "raises an error if the slice class is anonymous" do
+      expect { Class.new(described_class).prepare }
+        .to raise_error Hanami::SliceLoadError, /Slice must have a class name/
+    end
+  end
+end

data/spec/unit/hanami/version_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe "Hanami::VERSION" do
+  it "returns current version" do
+    expect(Hanami::VERSION).to eq("2.0.0.beta1")
+  end
+end

data/spec/unit/hanami/web/rack_logger_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "hanami/web/rack_logger"
+require "hanami/logger"
+require "stringio"
+require "rack/mock"
+
+RSpec.describe Hanami::Web::RackLogger do
+  subject { described_class.new(logger) }
+  let(:logger) { Hanami::Logger.new(app_name, stream: stream, level: Hanami::Logger::DEBUG, filter: filters) }
+  let(:stream) { StringIO.new }
+  let(:filters) { ["user.password"] }
+  let(:app_name) { "my_app" }
+
+  describe "#initialize" do
+    it "returns an instance of #{described_class}" do
+      expect(subject).to be_kind_of(described_class)
+    end
+  end
+
+  describe "#log_request" do
+    it "logs current request" do
+      time = Time.parse("2022-02-04 11:38:25.218816 +0100")
+      expect(Time).to receive(:now).at_least(:once).and_return(time)
+
+      path = "/users"
+      ip = "127.0.0.1"
+      status = 200
+      elapsed = 0.0001
+      content_length = 23
+      verb = "POST"
+
+      env = Rack::MockRequest.env_for(path, method: verb)
+      env["Content-Length"] = content_length
+      env["REMOTE_ADDR"] = ip
+
+      params = {"user" => {"password" => "secret"}}
+      env["router.params"] = params
+
+      subject.log_request(env, status, elapsed)
+
+      stream.rewind
+      actual = stream.read
+
+      expect(actual).to include(%([#{app_name}] [INFO] [#{time}] #{verb} #{status} #{elapsed}ms #{ip} #{path} #{content_length} {"user"=>{"password"=>"[FILTERED]"}}))
+    end
+
+    context "ip" do
+      it "takes into account HTTP proxy forwarding" do
+        env = Rack::MockRequest.env_for("/")
+        env["REMOTE_ADDR"] = remote = "127.0.0.1"
+        env["HTTP_X_FORWARDED_FOR"] = forwarded = "::1"
+
+        subject.log_request(env, 200, 0.1)
+
+        stream.rewind
+        actual = stream.read
+
+        expect(actual).to include(forwarded)
+        expect(actual).to_not include(remote)
+      end
+    end
+
+    context "path prefix" do
+      it "logs full referenced relative path" do
+        env = Rack::MockRequest.env_for(path = "/users")
+        env["SCRIPT_NAME"] = script_name = "/v1"
+
+        subject.log_request(env, 200, 0.1)
+
+        stream.rewind
+        actual = stream.read
+
+        expect(actual).to include(script_name + path)
+      end
+    end
+  end
+end